@superutils/fetch 1.2.1 → 1.2.2

package/README.md

@@ -4,19 +4,28 @@ A lightweight `fetch` wrapper for browsers and Node.js, designed to simplify dat
 
 This package enhances the native `fetch` API by providing a streamlined interface and integrating practical & useful features from `@superutils/promise`. It offers built-in support for automatic retries, request timeouts, interceptors, and effortless request cancellation, making complex asynchronous flows simple and manageable.
 
+<div v-if="false">
+
+For full API reference check out the [docs page](https://alien45.github.io/superutils/packages/@superutils/fetch/).
+
+</div>
+
 ## Table of Contents
 
 - Features
 - Installation
 - Usage
-    - [`fetch()`](#fetch): make HTTP requests just like built-in `fetch()`
+    - [`fetch()`](#fetch): drop-in replacement for built-in `fetch()`
+    - [`PromisE Features`](#promise-features): status, early finalization etc
     - [`Method Specific Functions`](#methods)
+    - [`fetch.get()`](#fetch-get)
     - [`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()`
     - [`Retry`](#retry) Retry on request failure
     - [`Timeout`](#timeout) Abort request on timeout
     - [`Interceptors/Transformers`](#interceptors)
+    - [`Reusable Clients`](#reusable-clients)
 
 ## Features
 
@@ -40,7 +49,7 @@ npm install @superutils/fetch
 
 ### `fetch(url, options)`
 
-Use as a drop-in replacement to the built-in `fetch()`.
+Use as a drop-in replacement to built-in `fetch()`.
 
 ```javascript
 import fetch from '@superutils/fetch'
@@ -50,6 +59,48 @@ fetch('https://dummyjson.com/products/1')
 	.then(console.log)
 ```
 
+<div id="promise-features"></div>
+
+### PromisE Instance: status, early cancellation
+
+All fetch calls return a `PromisE` (`@superutils/promise`) instance which means they come with additional features available in `PromisE`:
+
+1. Status tracking: all instances come with `.pending`, `.resolved` and `.rejected` attributes that indicate the current state of the promise.
+
+    ```javascript
+    import fetch from '@superutils/fetch'
+
+    const request = fetch('https://dummyjson.com/products/1')
+
+    console.log(request.pending) // true
+
+    request.then(() => {
+    	console.log(request.resolved) // true
+    	console.log(request.pending) // false
+    	console.log(request.rejected) // false
+    })
+    ```
+
+2. Early finalization: all `PromisE` instances expose `.resolve()` and `.reject()` methods that allow early finalization and `.onEarlyFinalize` array that allows adding callbacks to be executed when the promise is finalized externally using these methods. Fetch promises utilize this to abort the request when appropriate.
+
+    ```javascript
+    import fetch from '@superutils/fetch'
+
+    // Request that will take 5 seconds to resolve
+    const request = fetch('https://dummyjson.com/products?delay=5000')
+
+    request.then(result => console.log(result), console.warn)
+
+    // Add a callback to do stuff whenever request is aborted externally.
+    // This will not be invoked if fetch fails or resolves (promise finalized naturally) using the Promise executor.
+    request.onEarlyFinalize.push((resolved, valueOrReason) =>
+    	console.log('Aborted externally:', { resolved, valueOrReason }),
+    )
+
+    // resolve/reject before the promise is finalized
+    request.reject(new Error('No longer needed'))
+    ```
+
 <div id="methods"></div>
 
 ### Method Specific Functions
@@ -76,6 +127,14 @@ While `fetch()` provides access to all HTTP request methods by specifying it in
 
 All method specific functions by default return result parsed as JSON. No need for `response.json()` or `result.data.data` drilling.
 
+<div id="fetch-get"></div>
+
+### `fetch.get(url, options)`
+
+Performs a GET request and returns the result parsed as JSON by default.
+
+Equivalent to `fetch(url, { method: 'get', as: 'json' })`.
+
 ```javascript
 import fetch from '@superutils/fetch'
 
@@ -437,3 +496,36 @@ fetch.get('https://dummyjson.com/products/1', {
 	as: FetchAs.text,
 })
 ```
+
+<div id="reusable-clients"></div>
+
+### `createClient(method, )`: Reusable Clients
+
+The `createClient` utility allows you to generate pre-configured fetch functions with default options, such as headers, timeouts, or specific HTTP methods. This is ideal for creating dedicated API clients for specific services to avoid repetition.
+
+```javascript
+import { createClient } from '@superutils/fetch'
+
+// Create a client with default headers and a 5-second timeout
+const apiClient = createClient(undefined, {
+	headers: {
+		Authorization: 'Bearer my-secret-token',
+		'Content-Type': 'application/json',
+	},
+	timeout: 5000,
+})
+
+// Use it just like the standard fetch
+apiClient('https://dummyjson.com/products/1').then(console.log)
+
+// Create a specialized POST client
+const createProduct = createClient(
+	'get', // if provided will force all requests to be of this
+	{ timeout: 10000 },
+)
+
+// No need to specify method: 'post'
+createProduct('https://dummyjson.com/products/add', {
+	body: JSON.stringify({ title: 'New Product' }),
+}).then(console.log)
+```

package/dist/index.d.ts

@@ -1,12 +1,14 @@
 import * as _superutils_promise from '@superutils/promise';
-import { RetryOptions, IPromisE, DeferredAsyncOptions } from '@superutils/promise';
+import { RetryOptions, DeferredAsyncOptions, IPromisE } from '@superutils/promise';
 export { DeferredAsyncOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
 import { ValueOrPromise } from '@superutils/core';
 
-type FetchArgs<OmitMethod extends boolean = false> = [
-    url: string | URL,
-    options?: OmitMethod extends true ? Omit<FetchOptions, 'method'> : FetchOptions
-];
+type ExcludeOptions<Target, // options to exclude
+Options extends FetchOptions = FetchOptions> = Target extends FetchOptions ? {
+    headers?: Options['headers'];
+} & Omit<Options, 'headers' | keyof Target> & Partial<Record<Exclude<keyof Target, 'headers'>, never>> : Options;
+type ExcludePostOptions<Target> = ExcludeOptions<Target, PostOptions>;
+type FetchArgs = [url: string | URL, options?: FetchOptions];
 type FetchArgsInterceptor = [
     url: string | URL,
     options: FetchOptionsInterceptor
@@ -20,6 +22,10 @@ declare enum FetchAs {
     response = "response",
     text = "text"
 }
+/** Extract `FetchAs` from `FetchOptions` */
+type FetchAsFromOptions<TOptions, TFallback = FetchAs.json> = TOptions extends {
+    as: infer As;
+} ? As extends FetchAs ? As : TFallback : TFallback;
 /** Custom fetch options (not used by built-in `fetch()`*/
 type FetchCustomOptions = {
     /**
@@ -28,10 +34,12 @@ type FetchCustomOptions = {
      */
     as?: FetchAs;
     abortCtrl?: AbortController;
+    body?: PostBody | (() => PostBody);
     errMsgs?: FetchErrMsgs;
     interceptors?: FetchInterceptors;
     /** Request timeout in milliseconds. */
     timeout?: number;
+    validateUrl?: boolean;
 } & FetchRetryOptions;
 /** Default args */
 type FetchDeferredArgs<OmitMethod extends boolean = false> = [
@@ -214,7 +222,7 @@ type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Int
  * ---
  * 1. Any exception thrown by interceptors will gracefully ignored.
  * 2. Interceptors will be executed in the sequence they're given.
- * 3. Execution priority: global interceprors will always be executed before local interceptors.
+ * 3. Execution priority: global interceptors will always be executed before local interceptors.
  *
  *
  *
@@ -236,7 +244,7 @@ type FetchInterceptors = {
 /**
  * Fetch request options
  */
-type FetchOptions = RequestInit & FetchCustomOptions;
+type FetchOptions = Omit<RequestInit, 'body'> & FetchCustomOptions;
 type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'as' | 'method' | 'retryIf'>;
 /**
  * Fetch options available to interceptors
@@ -284,55 +292,68 @@ type PostArgs<OmitMethod = false> = [
     options?: OmitMethod extends true ? Omit<FetchOptions, 'method'> : PostOptions
 ];
 /**
- * Dynamic arguments for deffered post-like methods.
+ * Dynamic arguments for deferred post-like methods.
  *
  * @example
  * ```typescript
+ * import fetch, { type PostDeferredCbArgs } from '@superutils/fetch'
+ *
  * // test with types
- * type T1 = PostDeferredCallbackArgs<string | URL, undefined> // expected: [data, options]
- * type T2 = PostDeferredCallbackArgs<undefined, string> // expected: [url, options]
- * type T3 = PostDeferredCallbackArgs // expected: [url, data, options]
- * type T4 = PostDeferredCallbackArgs<string, string> // expected: [options]
+ * type T1 = PostDeferredCbArgs<string | URL, undefined> // expected: [data, options]
+ * type T2 = PostDeferredCbArgs<undefined, string> // expected: [url, options]
+ * type T3 = PostDeferredCbArgs // expected: [url, data, options]
+ * type T4 = PostDeferredCbArgs<string, string> // expected: [options]
  *
  * const data = { name: 'test' }
  * const url = 'https://domain.com'
- * // test with postDeferred()
- * const f1 = postDeferred({}, 'https://domain.com')
+ * // test with fetch.post.deferred()
+ * const f1 = fetch.post.deferred({}, 'https://domain.com')
  * // expected: [data, options]
  * f1({data: 1}).then(console.log, console.warn)
  *
- * const f2 = postDeferred({}, undefined, 'dome data')
+ * const f2 = fetch.post.deferred({}, undefined, 'dome data')
  * // expected: [url, options]
  * f2('https').then(console.log, console.warn)
  *
- * const f3 = postDeferred({})
+ * const f3 = fetch.post.deferred({})
  * // expected: [url, data, options]
  * f3('https://domain.com').then(console.log, console.warn)
  *
- * const f4 = postDeferred({}, 'url', 'data')
+ * const f4 = fetch.post.deferred({}, 'url', 'data')
  * // expected: [options]
  * f4().then(console.log, console.warn)
  * ```
  */
-type PostDeferredCbArgs<TUrl = undefined, TData = undefined, OmitMethod extends boolean = true, CbArgs extends PostArgs<OmitMethod> = PostArgs<OmitMethod>, Options = CbArgs[2], CbArgsReq extends unknown[] = Required<CbArgs>> = [TUrl, TData] extends [CbArgsReq[0], undefined] ? [data?: CbArgs[1], options?: Options] : [TUrl, TData] extends [undefined, CbArgsReq[1]] ? [url: CbArgs[0], options?: Options] : [TUrl, TData] extends [CbArgsReq[0], CbArgsReq[1]] ? [options?: Options] : CbArgs;
-type PostOptions = Omit<FetchOptions, 'method'> & {
+type PostDeferredCbArgs<TUrl = undefined, TData = undefined, Options = PostOptions, CbArgsReq extends unknown[] = Required<PostArgs>> = [TUrl, TData] extends [CbArgsReq[0], undefined] ? [data?: PostArgs[1], options?: Options] : [TUrl, TData] extends [undefined, CbArgsReq[1]] ? [url: PostArgs[0], options?: Options] : [TUrl, TData] extends [CbArgsReq[0], CbArgsReq[1]] ? [options?: Options] : PostArgs;
+type PostOptions = {
     /** Default: `'post'` */
     method?: 'post' | 'put' | 'patch' | 'delete' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-};
+} & Omit<FetchOptions, 'method'>;
 
-/** 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 reusable fetch client with shared options. The returned function comes attached with a
+ * `.deferred()` function for debounced and throttled request.
+ */
+declare const createClient: <MandatoryOpts extends FetchOptions | undefined, CommonOpts extends ExcludeOptions<MandatoryOpts> | undefined, MandatoryAs extends FetchAs | undefined = FetchAsFromOptions<MandatoryOpts, undefined>>(
+/** Mandatory fetch options that cannot be overriden by individual request */
+mandatoryOptions?: MandatoryOpts, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: FetchOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
+    <T, TOptions extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined, TAs extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions): IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludeOptions<MandatoryOpts> | undefined = ExcludeOptions<MandatoryOpts> | undefined, TAs_1 extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: DefaultUrl extends undefined ? [url: FetchArgs[0], options?: TOptions_1] : [options?: TOptions_1]) => IPromisE<TReturn_1>;
 };
 
 /**
- * Create a method-specific function for POST-like methods that automatically stringifies `data`
- * and attached with a `.deferred()` function
+ * Create a reusable fetch client with shared options. The returned function comes attached with a
+ * `.deferred()` function for debounced and throttled request.
  */
-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 createPostClient: <MandatoryOpts extends PostOptions | undefined, CommonOpts extends ExcludePostOptions<MandatoryOpts> | undefined, MandatoryAs extends FetchAs | undefined = FetchAsFromOptions<MandatoryOpts, undefined>>(
+/** Mandatory fetch options that cannot be overriden by individual request */
+mandatoryOptions?: MandatoryOpts, 
+/** Common fetch options that can be overriden by individual request */
+commonOptions?: PostOptions & CommonOpts, commonDeferOptions?: DeferredAsyncOptions<unknown, unknown>) => {
+    <T, TOptions extends ExcludePostOptions<MandatoryOpts> | undefined, TAs extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions, FetchAsFromOptions<CommonOpts>>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions): IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ExcludePostOptions<MandatoryOpts> | undefined = ExcludePostOptions<MandatoryOpts> | undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: DefaultOptions): <TResult = unknown, TOptions_1 extends ExcludePostOptions<MandatoryOpts> | undefined = ExcludePostOptions<MandatoryOpts> | undefined, TAs_1 extends FetchAs = MandatoryAs extends FetchAs ? MandatoryAs : FetchAsFromOptions<TOptions_1, FetchAsFromOptions<CommonOpts>>, TReturn_1 = FetchResult<TResult>[TAs_1]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions_1>) => IPromisE<TReturn_1>;
 };
 
 /**
@@ -379,32 +400,108 @@ declare const fetch: {
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: FetchArgs[0], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends FetchArgs[0] | undefined = string | URL | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<FetchOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: DefaultUrl extends undefined ? [url: string | URL, options?: TOptions | undefined] : [options?: TOptions | undefined]) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
 };
 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>;
+    <T, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<T>[TAs]>(url: PostArgs[0], data?: PostArgs[1], options?: TOptions | undefined): _superutils_promise.IPromisE<TReturn>;
+    deferred<ThisArg = unknown, TDelay extends number = number, DefaultUrl extends PostArgs[0] | undefined = string | URL | undefined, DefaultData extends PostArgs[1] = PostBody | (() => PostBody) | undefined, DefaultOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, TDelay>, defaultUrl?: DefaultUrl | undefined, defaultData?: DefaultData | undefined, defaultOptions?: DefaultOptions | undefined): <TResult = unknown, TOptions extends ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined = ({
+        headers?: HeadersInit | undefined;
+    } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined, TAs extends FetchAs = FetchAsFromOptions<TOptions, FetchAs.json>, TReturn = FetchResult<TResult>[TAs]>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, TOptions, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TReturn>;
 };
 type FetchWithMethods = typeof fetchResponse & {
     /** Default options */
@@ -532,192 +629,10 @@ type FetchWithMethods = typeof fetchResponse & {
  */
 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,
- * throttling API calls, or ensuring sequential request execution.
- *
- * It leverages the robust capabilities of the underlying {@link fetch} function, which includes features like request timeouts and manual abortion.
- * `fetchDeferred` uses this to automatically abort pending requests when a new one is initiated, preventing race conditions and redundant network traffic.
- *
- * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
- * See {@link DeferredAsyncOptions} for details.
- * @param defaultUrl (optional) If a global URL is `undefined`, returned callback will always require an URL.
- * @param defaultOptions (optional) Default {@link FetchOptions} to be used by the returned function.
- * Default options will be merged with the options provided in the callback.
- * If the same property is provided in both cases, defaults will be overriden by the callback.
- *
- * @example Debounce/Throttle requests for an auto-complete search input
- * ```typescript
- * import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
- *
- * // Create a debounced search function with a 300ms delay.
- * const searchProducts = fetchDeferred({
- * 	delayMs: 300, // Debounce delay
- * 	resolveIgnored: ResolveIgnored.WITH_UNDEFINED, // Ignored (aborted) promises will resolve with `undefined`
- * })
- *
- * // User types 'iphone'
- * searchProducts('https://dummyjson.com/products/search?q=iphone').then(result => {
- *   console.log('Result for "iphone":', result);
- * });
- *
- * // Before 300ms has passed, the user continues typing 'iphone 9'
- * setTimeout(() => {
- *   searchProducts('https://dummyjson.com/products/search?q=iphone 9').then(result => {
- *     console.log('Result for "iphone 9":', result);
- *   });
- * }, 200);
- *
- * // Outcome:
- * // The first request for "iphone" is aborted.
- * // The first promise resolves with `undefined`.
- * // The second request for "iphone 9" is executed after the 300ms debounce delay.
- * ```
- *
- * @example Creating a reusable, pre-configured client
- * ```typescript
- * import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
- *
- * // Create a throttled function to fetch a random quote.
- * // The URL and a 3-second timeout are set as defaults, creating a reusable client.
- * const getRandomQuote = fetchDeferred(
- * 	{
- * 		delayMs: 300, // Throttle window
- * 		throttle: true,
- *      // Ignored calls will resolve with the result of the last successful call.
- * 		resolveIgnored: ResolveIgnored.WITH_LAST,
- * 	},
- * 	'https://dummyjson.com/quotes/random', // Default URL
- * 	{ timeout: 3000 }, // Default fetch options
- * )
- *
- * // Call the function multiple times in quick succession.
- * getRandomQuote().then(quote => console.log('Call 1 resolved:', quote.id));
- * getRandomQuote().then(quote => console.log('Call 2 resolved:', quote.id));
- * getRandomQuote().then(quote => console.log('Call 3 resolved:', quote.id));
- *
- * // Outcome:
- * // Due to throttling, only one network request is made.
- * // Because `resolveIgnored` is `WITH_LAST`, all three promises resolve with the same quote.
- * // The promises for the two ignored calls resolve as soon as the first successful call resolves.
- * // Console output will show the same quote ID for all three calls.
- * ```
- */
-declare function fetchDeferred<ThisArg = unknown, Delay extends number = number, DefaultUrl = FetchArgs[0] | undefined, CbArgs extends unknown[] = undefined extends DefaultUrl ? FetchArgs<false> : [options?: FetchArgs<false>[1]]>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultOptions?: FetchArgs[1]): <TResult = unknown>(...args: CbArgs) => _superutils_promise.IPromisE<TResult>;
-
-/**
- * Creates a deferred/throttled function for making `DELETE`, `POST`, `PUT`, or `PATCH` requests, powered by
- * {@link PromisE.deferred}.
- *
- * This is ideal for scenarios like auto-saving form data, preventing duplicate submissions on button clicks,
- * or throttling API updates.
- *
- * Like `fetchDeferred`, it automatically aborts pending requests when a new one is initiated, ensuring only
- * the most recent or relevant action is executed.
- *
- * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
- * See {@link DeferredAsyncOptions} for details.
- * @param defaultUrl (optional) If default URL is `undefined`, returned callback will always require an URL.
- * @param defaultData (optional) If default data is `undefined`, returned callback will allow a data parameter.
- * @param defaultOptions (optional) Default {@link FetchOptions} to be used by the returned function.
- * Default options will be merged with the options provided in the callback.
- * If the same property is provided in both cases, defaults will be overriden by the callback.
- *
- *
- * #### Example 1: Auto-saving form data with throttling
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- * import PromisE from '@superutils/promise'
- *
- * // Create a throttled function to auto-save product updates.
- * const saveProductThrottled = fetch.post.deferred(
- * 	{
- * 		delayMs: 1000, // Throttle window of 1 second
- * 		throttle: true,
- * 		trailing: true, // Ensures the very last update is always saved
- * 		onResult: product => console.log(`[Saved] Product: ${product.title}`),
- * 	},
- * 	'https://dummyjson.com/products/add', // Default URL
- * )
- * // Simulate a user typing quickly, triggering multiple saves.
- * console.log('User starts typing...')
- *
- * // Executed immediately (leading edge)
- * saveProductThrottled({ title: 'iPhone' })
- * // Ignored (within 1000ms throttle window)
- * PromisE.delay(200, () => saveProductThrottled({ title: 'iPhone 15' }))
- * // Ignored
- * PromisE.delay(300, () => saveProductThrottled({ title: 'iPhone 15 Pro' }))
- * // Queued to execute on the trailing edge
- * PromisE.delay(400, () => saveProductThrottled({ title: 'iPhone 15 Pro Max' }))
- * // Outcome:
- * // The first call ('iPhone') is executed immediately.
- * // The next two calls are ignored by the throttle.
- * // The final call ('iPhone 15 Pro Max') is executed after the 1000ms throttle window closes,
- * // thanks to `trailing: true`.
- * // This results in only two network requests instead of four.
- * ```
- *
- * #### Example 2: debouncing an authentication token refresh
- *
- * ```typescript
- * import fetch from '@superutils/fetch'
- * import PromisE from '@superutils/promise'
- *
- * // Mock a simple token store
- * let currentRefreshToken = ''
- * // Create a debounced function to refresh the auth token.
- * // It waits 300ms after the last call before executing.
- * const requestNewToken = fetch.post.deferred(
- * 	{
- * 		delayMs: 300, // debounce delay
- * 		onResult: ({ refreshToken = '' }) => {
- * 			console.log(
- * 				`Auth token successfully refreshed at ${new Date().toISOString()}`,
- * 			)
- * 			currentRefreshToken = refreshToken
- * 		},
- * 	},
- * 	'https://dummyjson.com/auth/refresh', // Default URL
- * 	() => ({
- * 		refreshToken: currentRefreshToken,
- * 		expiresInMins: 30,
- * 	}),
- * )
- *
- * // First authenticate user to get the initial refresh token and then request new referesh tokens
- * fetch
- * 	.post<{ refreshToken: string }>(
- * 		'https://dummyjson.com/auth/login',
- * 		{
- * 			username: 'emilys',
- * 			password: 'emilyspass',
- * 			expiresInMins: 30,
- * 		},
- * 		{ credentials: 'include' },
- * 	)
- * 	.then(result => {
- * 		currentRefreshToken = result?.refreshToken
- *
- * 		requestNewToken() // Called at 0ms
- * 		PromisE.delay(50, requestNewToken) // Called at 50ms
- * 		PromisE.delay(100, requestNewToken) // Called at 100ms
- * 	}, console.error)
- * // Outcome:
- * // The first two calls are aborted by the debounce mechanism.
- * // Only the final call executes, 300ms after it was made (at the 400ms mark).
- * // The token is refreshed only once, preventing redundant network requests.
- * ```
- */
-declare function postDeferred<ThisArg, Delay = unknown, DefaultUrl extends PostArgs[0] | undefined = undefined, DefaultData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<DefaultUrl, DefaultData, false>>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, defaultUrl?: DefaultUrl, defaultData?: DefaultData, defaultOptions?: PostArgs[2]): <TResult = unknown>(...args: CbArgs) => _superutils_promise.IPromisE<TResult>;
-
 /**
  * Merge one or more {@link FetchOptions}
  *
  * Notes:
- * - {@link config.fetchOptions} will be added as the base and not necessary to be included
  * - item properties will be prioritized in the order of sequence they were passed in
  * - the following properties will be merged
  *     * `errMsgs`
@@ -729,4 +644,7 @@ declare function postDeferred<ThisArg, Delay = unknown, DefaultUrl extends PostA
  */
 declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptionsInterceptor;
 
-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 };
+/** Merges partial fetch options ignoring empty or undefined. Otherwise, will return the first argument. */
+declare const mergePartialOptions: (...optionsAr: (Partial<FetchOptions> | undefined)[]) => Partial<FetchOptions> | undefined;
+
+export { type ExcludeOptions, type ExcludePostOptions, type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchAsFromOptions, 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, createClient, createPostClient, fetchDefault as default, fetch, fetchResponse, mergeFetchOptions, mergePartialOptions };

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/createClient.ts
+import PromisE3 from "@superutils/promise";
+
 // src/fetch.ts
 import {
   fallbackIfFails as fallbackIfFails2,
@@ -10,9 +13,9 @@ import PromisE2 from "@superutils/promise";
 
 // src/executeInterceptors.ts
 import { fallbackIfFails, isFn } from "@superutils/core";
-var executeInterceptors = async (value, interceptors, ...args) => {
+var executeInterceptors = async (value, interceptors = [], ...args) => {
   var _a;
-  for (const interceptor of interceptors.filter(isFn)) {
+  for (const interceptor of [...interceptors || []].filter(isFn)) {
     value = (_a = await fallbackIfFails(
       interceptor,
       [value, ...args],
@@ -28,7 +31,8 @@ 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);
+  if (!isPositiveInteger(options.retry))
+    return fetchFunc(url, options);
   let attemptCount = 0;
   const response = PromisE.retry(
     () => {
@@ -92,6 +96,10 @@ var mergeFetchOptions = (...allOptions) => allOptions.reduce(
   { headers: new Headers() }
 );
 var mergeFetchOptions_default = mergeFetchOptions;
+var mergePartialOptions = (...optionsAr) => {
+  optionsAr = optionsAr.filter((x) => !isEmpty(x));
+  return optionsAr.length <= 1 ? optionsAr[0] : mergeFetchOptions(...optionsAr);
+};
 
 // src/types.ts
 import {
@@ -129,18 +137,25 @@ var fetch = (url, options = {}) => {
   let abortCtrl;
   let timeoutId;
   const promise = new PromisE2(async (resolve, reject) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
+    let errResponse;
     const _options2 = mergeFetchOptions_default(fetch.defaults, options);
     (_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, _options2);
-    const { as: parseAs, errMsgs, timeout } = _options2;
+    _options2.abortCtrl = _options2.abortCtrl instanceof AbortController ? _options2.abortCtrl : new AbortController();
+    url = await executeInterceptors_default(
+      url,
+      _options2.interceptors.request,
+      _options2
+    );
+    const {
+      as: parseAs,
+      body,
+      errMsgs,
+      timeout,
+      validateUrl = true
+    } = _options2;
     if (isPositiveNumber(timeout)) {
-      (_c = _options2.abortCtrl) != null ? _c : _options2.abortCtrl = new AbortController();
       timeoutId = setTimeout(() => {
         var _a2;
         return (_a2 = _options2.abortCtrl) == null ? void 0 : _a2.abort();
@@ -148,13 +163,17 @@ var fetch = (url, options = {}) => {
     }
     abortCtrl = _options2.abortCtrl;
     if (_options2.abortCtrl) _options2.signal = _options2.abortCtrl.signal;
-    let errResponse;
     try {
-      if (!isUrlValid(url, false)) throw new Error(errMsgs.invalidUrl);
+      if (validateUrl && !isUrlValid(url, false))
+        throw new Error(errMsgs.invalidUrl);
+      if (!["undefined", "string"].includes(typeof body))
+        _options2.body = JSON.stringify(
+          isFn2(body) ? fallbackIfFails2(body, [], void 0) : body
+        );
       let response = await getResponse_default(url, _options2);
       response = await executeInterceptors_default(
         response,
-        responseInterceptors,
+        _options2.interceptors.response,
         url,
         _options2
       );
@@ -189,7 +208,7 @@ var fetch = (url, options = {}) => {
       }
       result = await executeInterceptors_default(
         result,
-        resultInterceptors,
+        _options2.interceptors.result,
         url,
         _options2
       );
@@ -198,14 +217,14 @@ var fetch = (url, options = {}) => {
       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: (_d = errX == null ? void 0 : errX.cause) != null ? _d : err,
+        cause: (_c = errX == null ? void 0 : errX.cause) != null ? _c : err,
         response: errResponse,
         options: _options2,
         url
       });
       error = await executeInterceptors_default(
         error,
-        errorInterceptors,
+        _options2.interceptors.error,
         url,
         _options2
       );
@@ -238,101 +257,95 @@ fetch.defaults = {
     result: []
   },
   /** Request timeout duration in milliseconds. Default: `0` */
-  timeout: 0
+  timeout: 0,
+  validateUrl: true
 };
 var fetch_default = fetch;
 
-// src/fetchDeferred.ts
-import PromisE3 from "@superutils/promise";
-function fetchDeferred(deferOptions = {}, defaultUrl, defaultOptions) {
-  let _abortCtrl;
-  const fetchCallback = (...args) => {
-    var _a, _b, _c;
-    let options = (_a = defaultUrl === void 0 ? args[1] : args[0]) != null ? _a : {};
-    if (defaultOptions) options = mergeFetchOptions_default(defaultOptions, options);
-    (_b = options.abortCtrl) != null ? _b : options.abortCtrl = new AbortController();
-    (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
-    _abortCtrl = options.abortCtrl;
-    const promise = fetch_default(
-      defaultUrl != null ? defaultUrl : args[0],
-      options
+// src/createClient.ts
+var createClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
+  const func = (url, options) => {
+    return fetch_default(
+      url,
+      mergePartialOptions(
+        commonOptions,
+        options,
+        mandatoryOptions
+      )
     );
-    promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
-    return promise;
   };
-  return PromisE3.deferredCallback(fetchCallback, deferOptions);
-}
-var fetchDeferred_default = fetchDeferred;
-
-// 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);
+  func.deferred = (deferOptions = {}, defaultUrl, defaultOptions) => {
+    let _abortCtrl;
+    const fetchCb = (...args) => {
+      var _a, _b;
+      const options = mergePartialOptions(
+        commonOptions,
+        defaultOptions,
+        defaultUrl === void 0 ? args[1] : args[0],
+        mandatoryOptions
+      );
+      (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
+      (_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl);
+      _abortCtrl = options.abortCtrl;
+      const promise = fetch_default(
+        defaultUrl != null ? defaultUrl : args[0],
+        options
+      );
+      promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
+      return promise;
+    };
+    return PromisE3.deferredCallback(fetchCb, {
+      ...commonDeferOptions,
+      ...deferOptions
+    });
   };
-  return methodFunc;
+  return func;
 };
-var createFetchMethodFunc_default = createFetchMethodFunc;
+var createClient_default = createClient;
 
-// src/post.ts
-import { isFn as isFn3, isStr } from "@superutils/core";
-function post(...[url = "", 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
+// src/createPostClient.ts
 import PromisE4 from "@superutils/promise";
-function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions) {
-  let _abortCtrl;
-  const doPost = (...args) => {
-    var _a, _b, _c;
-    if (defaultUrl !== void 0) args.splice(0, 0, defaultUrl);
-    if (defaultData !== void 0) args.splice(1, 0, defaultData);
-    const options = mergeFetchOptions_default(defaultOptions != null ? defaultOptions : {}, (_a = args[2]) != null ? _a : {});
-    (_b = options.abortCtrl) != null ? _b : options.abortCtrl = new AbortController();
-    (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
-    _abortCtrl = options.abortCtrl;
-    const promise = post(
-      args[0],
-      args[1],
-      options
+var createPostClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
+  const func = (url, data, options) => {
+    var _a;
+    const _options2 = mergePartialOptions(
+      commonOptions,
+      options,
+      mandatoryOptions
     );
-    promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
-    return promise;
-  };
-  return PromisE4.deferredCallback(doPost, deferOptions);
-}
-var postDeferred_default = postDeferred;
-
-// src/createPostMethodFunc.ts
-var createPostMethodFunc = (method = "post") => {
-  const methodFunc = (url, data, options) => {
-    options != null ? options : options = {};
-    options.method = method;
-    return post(url, data, options);
+    _options2.body = data;
+    (_a = _options2.method) != null ? _a : _options2.method = "post";
+    return fetch_default(url, _options2);
   };
-  methodFunc.deferred = (...args) => {
-    var _a;
-    (_a = args[3]) != null ? _a : args[3] = {};
-    args[3].method = method;
-    return postDeferred_default(...args);
+  func.deferred = (deferOptions = {}, defaultUrl, defaultData, defaultOptions) => {
+    let _abortCtrl;
+    const postCb = (...args) => {
+      var _a, _b, _c, _d;
+      if (defaultUrl !== void 0) args.splice(0, 0, defaultUrl);
+      if (defaultData !== void 0) args.splice(1, 0, defaultData);
+      const options = mergePartialOptions(
+        commonOptions,
+        defaultOptions,
+        args[2],
+        mandatoryOptions
+      );
+      (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
+      (_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl);
+      _abortCtrl = options.abortCtrl;
+      options.body = (_c = args[1]) != null ? _c : options.body;
+      (_d = options.method) != null ? _d : options.method = "post";
+      const promise = fetch_default(args[0], options);
+      promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
+      return promise;
+    };
+    return PromisE4.deferredCallback(postCb, {
+      ...commonDeferOptions,
+      ...deferOptions
+    });
   };
-  return methodFunc;
+  return func;
 };
-var createPostMethodFunc_default = createPostMethodFunc;
+var createPostClient_default = createPostClient;
 
 // src/fetchResponse.ts
 var fetchResponse = (...args) => {
@@ -344,13 +357,13 @@ var fetchResponse = (...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 _get = createClient_default({ method: "get" });
+var _head = createClient_default({ method: "head" });
+var _options = createClient_default({ method: "options" });
+var _delete = createPostClient_default({ method: "delete" });
+var _patch = createPostClient_default({ method: "patch" });
+var _post = createPostClient_default({ method: "post" });
+var _put = createPostClient_default({ method: "put" });
 var fetchDefault = fetchResponse_default;
 Object.defineProperty(fetchDefault, "defaults", {
   get() {
@@ -376,12 +389,11 @@ export {
   FetchError,
   ResolveError,
   ResolveIgnored,
-  createFetchMethodFunc,
-  createPostMethodFunc,
+  createClient,
+  createPostClient,
   index_default as default,
   fetch,
-  fetchDeferred,
   fetchResponse,
   mergeFetchOptions,
-  postDeferred
+  mergePartialOptions
 };

package/package.json

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