@superutils/fetch 1.5.0 → 1.5.2

package/dist/index.cjs

@@ -23,11 +23,11 @@ __export(index_exports, {
   ContentType: () => ContentType,
   FetchAs: () => FetchAs,
   FetchError: () => FetchError,
-  ResolveError: () => import_promise2.ResolveError,
-  ResolveIgnored: () => import_promise2.ResolveIgnored,
-  TIMEOUT_FALLBACK: () => import_promise2.TIMEOUT_FALLBACK,
-  TIMEOUT_MAX: () => import_promise2.TIMEOUT_MAX,
-  TimeoutPromise: () => import_promise2.TimeoutPromise,
+  ResolveError: () => import_promise5.ResolveError,
+  ResolveIgnored: () => import_promise5.ResolveIgnored,
+  TIMEOUT_FALLBACK: () => import_promise5.TIMEOUT_FALLBACK,
+  TIMEOUT_MAX: () => import_promise5.TIMEOUT_MAX,
+  TimeoutPromise: () => import_promise5.TimeoutPromise,
   createClient: () => createClient,
   createPostClient: () => createPostClient,
   default: () => index_default,
@@ -36,13 +36,14 @@ __export(index_exports, {
   mergeOptions: () => mergeOptions
 });
 module.exports = __toCommonJS(index_exports);
+var import_promise5 = require("@superutils/promise");
 
 // src/createClient.ts
-var import_promise4 = require("@superutils/promise");
+var import_promise3 = require("@superutils/promise");
 
 // src/fetch.ts
 var import_core4 = require("@superutils/core");
-var import_promise3 = require("@superutils/promise");
+var import_promise2 = require("@superutils/promise");
 
 // src/executeInterceptors.ts
 var import_core = require("@superutils/core");
@@ -199,14 +200,25 @@ var FetchError = class _FetchError extends Error {
   }
 };
 
-// src/types/index.ts
-var import_promise2 = require("@superutils/promise");
-
 // src/fetch.ts
 var fetch = (url, options = {}) => {
   var _a, _b, _c;
+  if (!(0, import_core4.isObj)(options)) options = {};
+  let fromPostClient = false;
+  if (options.fromPostClient) {
+    delete options.fromPostClient;
+    fromPostClient = true;
+  }
   let response;
-  const opts = mergeOptions_default(fetch.defaults, options);
+  const opts = mergeOptions_default(
+    {
+      abortOnEarlyFinalize: fetch.defaults.abortOnEarlyFinalize,
+      errMsgs: fetch.defaults.errMsgs,
+      timeout: import_promise2.TIMEOUT_MAX,
+      validateUrl: false
+    },
+    options
+  );
   opts.abortCtrl = opts.abortCtrl instanceof AbortController ? opts.abortCtrl : new AbortController();
   (_a = opts.as) != null ? _a : opts.as = "response" /* response */;
   (_b = opts.method) != null ? _b : opts.method = "get";
@@ -234,32 +246,34 @@ var fetch = (url, options = {}) => {
       response
     );
   };
-  return (0, import_promise3.timeout)(opts, async () => {
+  return (0, import_promise2.timeout)(opts, async () => {
     var _a2, _b2, _c2, _d, _e;
     try {
-      let contentType = headers.get("content-type");
-      if (!contentType) {
-        headers.set("content-type", ContentType.APPLICATION_JSON);
-        contentType = ContentType.APPLICATION_JSON;
-      }
       url = await executeInterceptors_default(
         url,
         abortCtrl.signal,
         (_a2 = opts.interceptors) == null ? void 0 : _a2.request,
         opts
       );
-      const { body, errMsgs, validateUrl = true } = opts;
+      const { body, errMsgs, validateUrl = false } = opts;
       (_b2 = opts.signal) != null ? _b2 : opts.signal = abortCtrl.signal;
       if (validateUrl && !(0, import_core4.isUrlValid)(url, false))
         throw new Error(errMsgs.invalidUrl);
-      const shouldStringifyBody = [
-        ContentType.APPLICATION_JSON,
-        ContentType.APPLICATION_X_WWW_FORM_URLENCODED
-      ].find((x) => contentType.includes(x)) && !["undefined", "string"].includes(typeof body);
-      if (shouldStringifyBody)
-        opts.body = JSON.stringify(
-          (0, import_core4.isFn)(body) ? (0, import_core4.fallbackIfFails)(body, [], void 0) : body
-        );
+      if (fromPostClient) {
+        let contentType = headers.get("content-type");
+        if (!contentType) {
+          headers.set("content-type", ContentType.APPLICATION_JSON);
+          contentType = ContentType.APPLICATION_JSON;
+        }
+        const shouldStringifyBody = ["delete", "patch", "post", "put"].includes(
+          `${opts.method}`.toLowerCase()
+        ) && !["undefined", "string"].includes(typeof body) && (0, import_core4.isObj)(body, true) && contentType === ContentType.APPLICATION_JSON;
+        if (shouldStringifyBody) {
+          opts.body = JSON.stringify(
+            (0, import_core4.isFn)(body) ? (0, import_core4.fallbackIfFails)(body, [], void 0) : body
+          );
+        }
+      }
       response = await getResponse_default(url, opts);
       response = await executeInterceptors_default(
         response,
@@ -325,8 +339,8 @@ fetch.defaults = {
     response: [],
     result: []
   },
-  timeout: 3e4,
-  validateUrl: true
+  timeout: 6e4,
+  validateUrl: false
 };
 var interceptErr = async (err, url, options, response) => {
   var _a, _b, _c;
@@ -352,6 +366,7 @@ var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
   function client(url, options) {
     var _a;
     const mergedOptions = mergeOptions_default(
+      fetch_default.defaults,
       commonOptions,
       options,
       fixedOptions
@@ -365,6 +380,7 @@ var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
     const fetchCb = (...args) => {
       var _a, _b, _c;
       const mergedOptions = (_a = mergeOptions_default(
+        fetch_default.defaults,
         commonOptions,
         defaultOptions,
         defaultUrl === void 0 ? args[1] : args[0],
@@ -379,7 +395,7 @@ var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
         mergedOptions
       );
     };
-    return (0, import_promise4.deferredCallback)(fetchCb, {
+    return (0, import_promise3.deferredCallback)(fetchCb, {
       ...commonDeferOptions,
       ...deferOptions
     });
@@ -389,11 +405,12 @@ var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
 var createClient_default = createClient;
 
 // src/createPostClient.ts
-var import_promise5 = require("@superutils/promise");
+var import_promise4 = require("@superutils/promise");
 var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
   function client(url, data, options) {
     var _a, _b;
     const mergedOptions = mergeOptions_default(
+      fetch_default.defaults,
       commonOptions,
       options,
       fixedOptions
@@ -402,6 +419,7 @@ var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
     (_a = mergedOptions.as) != null ? _a : mergedOptions.as = "json" /* json */;
     mergedOptions.body = data;
     (_b = mergedOptions.method) != null ? _b : mergedOptions.method = "post";
+    mergedOptions.fromPostClient = true;
     return fetch_default(url, mergedOptions);
   }
   client.deferred = (deferOptions, defaultUrl, defaultData, defaultOptions) => {
@@ -411,6 +429,7 @@ var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
       if (defaultUrl !== void 0) args.splice(0, 0, defaultUrl);
       if (defaultData !== void 0) args.splice(1, 0, defaultData);
       const mergedOptions = (_a = mergeOptions_default(
+        fetch_default.defaults,
         commonOptions,
         defaultOptions,
         args[2],
@@ -422,9 +441,10 @@ var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
       _abortCtrl = new AbortController();
       mergedOptions.body = (_d = args[1]) != null ? _d : mergedOptions.body;
       (_e = mergedOptions.method) != null ? _e : mergedOptions.method = "post";
+      mergedOptions.fromPostClient = true;
       return fetch_default(args[0], mergedOptions);
     };
-    return (0, import_promise5.deferredCallback)(postCb, {
+    return (0, import_promise4.deferredCallback)(postCb, {
       ...commonDeferOptions,
       ...deferOptions
     });

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as _superutils_promise from '@superutils/promise';
 import { RetryOptions, RetryIfFunc, TimeoutOptions, IPromisE_Timeout, DeferredAsyncOptions } from '@superutils/promise';
-export { DeferredAsyncOptions, ResolveError, ResolveIgnored, TIMEOUT_FALLBACK, TIMEOUT_MAX, TimeoutPromise } from '@superutils/promise';
+export { DeferredAsyncOptions, OnEarlyFinalize, OnFinalize, ResolveError, ResolveIgnored, RetryIfFunc, RetryOptions, TIMEOUT_FALLBACK, TIMEOUT_MAX, TimeoutOptions, TimeoutPromise } from '@superutils/promise';
 import { ValueOrPromise, DropFirst } from '@superutils/core';
 
 /** Commonly used content types for easier access */
@@ -44,34 +44,36 @@ type Interceptor<T, TArgs extends unknown[]> = (...args: [value: T, ...TArgs]) =
  *
  * @returns returning undefined or not returning anything will not override the error
  *
- * @example	intercept fetch errors to log errors
- * ```typescript
- * import PromisE from '@superutils/promise'
+ * @example
+ * #### Intercept fetch errors to log errors
+ * ```javascript
+ * import fetch from '@superutils/fetch'
  *
  * // not returning anything or returning undefined will avoid transforming the error.
  * const logError = fetchErr => console.log(fetchErr)
- * const result = await PromisE.fetch('https://my.domain.com/api/that/fails', {
- *     interceptors: {
- *         error: [logError]
- *     }
+ * const result = await fetch.get('https://dummyjson.com/http/400', {
+ *   interceptors: {
+ *     error: [logError]
+ *   }
  * })
  * ```
  *
- * @example	intercept & transform fetch errors
- * ```typescript
- * import PromisE from '@superutils/promise'
+ * @example
+ * #### Intercept & transform fetch errors
+ * ```javascript
+ * import fetch from '@superutils/fetch'
  *
  * // Interceptors can be async functions or just return a promise that resolves to the error.
  * // If the execution of the interceptor fails or promise rejects, it will be ignored.
  * // To transform the error it must directly return an error or a Promise that `resolves` with an error.
  * const transformError = async (fetchErr, url, options) => {
- *     fetchErr.message = 'Custom errormessage'
- * 	   return Promise.resolve(fetchErr)
+ *   fetchErr.message = 'Custom errormessage'
+ * 	 return Promise.resolve(fetchErr)
  * }
- * const result = await PromisE.fetch('https://my.domain.com/api/that/fails', {
- *     interceptors: {
- *         error: [transformError]
- *     }
+ * const result = await fetch.get('https://dummyjson.com/http/400', {
+ *   interceptors: {
+ *     error: [transformError]
+ *   }
  * })
  * ```
  */
@@ -82,19 +84,21 @@ type FetchInterceptorError = Interceptor<FetchError, FetchArgsInterceptor>;
  * 1. by returning an API URL (string/URL)
  * 2. by modifying the properties of the options parameter to be used before making the fetch request
  *
- * @example intercept and transform fetch request
+ * @example
+ * #### Intercept and transform fetch request
  * ```typescript
- * import PromisE from '@superutils/promise'
+ * import fetch from '@superutils/fetch'
  *
  * // update API version number
  * const apiV1ToV2 = url => `${url}`.replace('api/v1', 'api/v2')
  * const includeAuthToken = (url, options) => {
- *     options.headers.set('x-auth-token', 'my-auth-token')
+ *   options.headers.set('x-auth-token', 'my-auth-token')
  * }
- * const data = await PromisE.fetch('https://my.domain.com/api', {
- *     interceptors: {
- *         result: [apiV1ToV2, includeAuthToken]
- *     }
+ * const result = await fetch.get('https://dummyjson.com/products', {
+ *   method: 'post',
+ *   interceptors: {
+ *       result: [apiV1ToV2, includeAuthToken]
+ *   }
  * })
  * ```
  */
@@ -106,24 +110,29 @@ type FetchInterceptorRequest = Interceptor<FetchArgs[0], [
  *
  * This interceptor can also be used as a transformer by return a different/modified {@link Response}.
  *
- * @example intercept and transform response:
- * ```typescript
- * import PromisE from '@superutils/promise'
+ * @example
+ * #### Intercept and transform response:
+ * ```javascript
+ * import fetch from '@superutils/fetch'
  *
- * // After successful login, retrieve user balance.
+ * // After successful login, retrieve full user details.
  * // This is probably better suited as a result transformer but play along as this is
  * // just a hypothetical scenario ;)
- * const includeBalance = async response => {
- *     const balance = await PromisE.fetch('https://my.domain.com/api/user/12325345/balance')
- * 	   const user = await response.json()
- *     user.balance = balance
- *     return new Response(JSON.stringify(user))
+ * const getUser = async response => {
+ * 	 const authResult = await response.json()
+ *   const userDetails = await fetch.get('https://dummyjson.com/users/1')
+ *   const userAuth = { ...userDetails, ...authResult }
+ *   return new Response(JSON.stringify(userAuth))
  * }
- * const user = await PromisE.fetch('https://my.domain.com/api/login', {
- *     interceptors: {
- *         response: [includeBalance]
- *     }
- * })
+ * const user = await fetch.post(
+ * 	'https://dummyjson.com/user/login',
+ *  {  // data/request body
+ *    username: 'emilys',
+ *    password: 'emilyspass',
+ *    expiresInMins: 30,
+ *  },
+ *  { interceptors: { response: [getUser] } }
+ * )
  * ```
  */
 type FetchInterceptorResponse = Interceptor<Response, FetchArgsInterceptor>;
@@ -140,32 +149,45 @@ type FetchInterceptorResponse = Interceptor<Response, FetchArgsInterceptor>;
  * This interceptor can also be used as a transformer by returns a different/modified result.
  *
  *
- * @example intercept and transform fetch result
- * ```typescript
- * import PromisE from '@superutils/promise'
+ * @example
+ * #### Intercept and transform fetch result
+ * ```javascript
+ * import fetch from '@superutils/fetch'
  *
- * // first transform result by extracting result.data
- * const extractData = result => result?.data ?? result
+ * // first transform result (user object) and ensure user result alwasy contain a hexadecimal crypto balance
+ * const ensureBalanceHex = (user = {}) => {
+ *   user.crypto ??= {}
+ *   user.crypto.balance ??= '0x0'
+ *   return user
+ * }
  * // then check convert hexadecimal number to BigInt
- * const hexToBigInt = data => {
- *     if (data.hasOwnProperty('balance') && `${data.balance}`.startsWith('0x')) {
- *          data.balance = BigInt(data.balance)
- *     }
- *     return data
+ * const hexToBigInt = user => {
+ *   user.crypto.balance = BigInt(user.crypto.balance)
+ *   return user
  * }
  * // then log balance (no transformation)
- * const logBalance = data => {
- *     data?.hasOwnProperty('balance') && console.log(data.balance)
+ * const logBalance = (result, url) => {
+ *   // only log balance for single user requests
+ *   const shouldLog = result?.hasOwnProperty('crypto') && /^[0-9]+$/.test(
+ *     url?.split('/users/')[1].replace('/', '')
+ *   )
+ *   shouldLog && console.log(
+ *     new Date().toISOString(),
+ *     '[UserBalance] UserID:', result.id,
+ *     result.crypto.balance
+ *   )
  * }
- * const data = await PromisE.fetch('https://my.domain.com/api', {
- *     interceptors: {
- *         result: [
- * 	           extractData,
- * 	           hexToBigInt,
- * 	           logBalance
- * 	       ]
- *     }
+ * // now we make the actaul fetch request
+ * const result = await fetch.get('https://dummyjson.com/users/1', {
+ *   interceptors: {
+ *     result: [
+ * 	     ensureBalanceHex,
+ * 	     hexToBigInt,
+ * 	     logBalance
+ * 	   ]
+ *   }
  * })
+ * console.log({result})
  * ```
  */
 type FetchInterceptorResult<Args extends unknown[] = FetchArgsInterceptor> = Interceptor<unknown, Args>;
@@ -277,7 +299,7 @@ type FetchCustomOptions = {
      * See {@link FetchInterceptors} for more details.
      */
     interceptors?: FetchInterceptors;
-    /** Whether to validate URL before making the request. Default: `true` */
+    /** Whether to validate URL before making the request. Default: `false` */
     validateUrl?: boolean;
 } & FetchRetryOptions & TimeoutOptions<[]>;
 /** Default args */
@@ -303,8 +325,24 @@ type FetchFunc = (...args: FetchArgs) => Promise<Response>;
  */
 type FetchOptions = Omit<RequestInit, 'body'> & FetchCustomOptions;
 /** Default fetch options */
-type FetchOptionsDefault = Omit<FetchOptionsInterceptor, 'abortCtrl' | 'as' | 'method' | 'signal' | 'timeout'> & {
-    /** Request timeout duration in milliseconds. Default: `30_000` (30 seconds) */
+type FetchOptionsDefault = Omit<FetchOptionsInterceptor, 'abortCtrl' | 'as' | 'method' | 'signal' | 'timeout' | 'headers'> & {
+    /**
+     * Request headers.
+     *
+     * Deafult:
+     * - No default content type set when `fetch()` is directly invoked.
+     * - `"content-type": "application/json"`: for `createPostClient()`, `fetch.post()`,
+     * `fetch.post.deferred()` and other method specific functions
+     */
+    headers: HeadersInit;
+    /**
+     * Request timeout duration in milliseconds.
+     *
+     * Default:
+     * - `30_000` for `createClient()`, `createPostClient()` and
+     * all method specific functions (`fetch.METHOD` & `fetch.METHOD.deferred()`
+     * - `2147483647` when `fetch()` invoked directly
+     */
     timeout: number;
 };
 /**
@@ -360,30 +398,10 @@ type PostArgs = [
  * ```typescript
  * import fetch, { type PostDeferredCbArgs } from '@superutils/fetch'
  *
- * // test with types
  * type T1 = PostDeferredCbArgs<string | URL, undefined> // expected: [data, options]
- * type T2 = PostDeferredCbArgs<undefined, string> // expected: [url, options]
+ * type T2 = PostDeferredCbArgs<string | 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 fetch.post.deferred()
- * const f1 = fetch.post.deferred({}, 'https://domain.com')
- * // expected: [data, options]
- * f1({data: 1}).then(console.log, console.warn)
- *
- * const f2 = fetch.post.deferred({}, undefined, 'dome data')
- * // expected: [url, options]
- * f2('https').then(console.log, console.warn)
- *
- * const f3 = fetch.post.deferred({})
- * // expected: [url, data, options]
- * f3('https://domain.com').then(console.log, console.warn)
- *
- * const f4 = fetch.post.deferred({}, 'url', 'data')
- * // expected: [options]
- * f4().then(console.log, console.warn)
  * ```
  */
 type PostDeferredCbArgs<DefaultUrl = undefined, DefaultData = undefined, Options = PostArgs[2], PostArgsReq extends unknown[] = Required<PostArgs>, _url = undefined extends DefaultUrl ? undefined : DefaultUrl, _data = undefined extends DefaultData ? undefined : DefaultData> = [_url, _data] extends [PostArgsReq[0], undefined] ? [
@@ -440,45 +458,41 @@ type ClientData<FixedOptions> = ExtractAs<[FixedOptions]> extends FetchAs.json ?
  * The returned client also includes a `.deferred()` method, providing the same debounce, throttle, and sequential
  * execution capabilities found in functions like `fetch.get.deferred()`.
  *
- * @example create reusable clients
+ * @example
+ * #### Create reusable clients
  * ```javascript
  * import { createClient } from '@superutils/fetch'
  *
  * // Create a "GET" client with default headers and a 5-second timeout
  * const apiClient = createClient(
- * 	{
- * 		// fixed options cannot be overridden
- * 		method: 'get',
- * 	},
- * 	{
- * 		// default options can be overridden
- * 		headers: {
- * 			Authorization: 'Bearer my-secret-token',
- * 			'Content-Type': 'application/json',
- * 		},
- * 		timeout: 5000,
- * 	},
- * 	{
- * 		// default defer options (can be overridden)
- * 		delay: 300,
- * 		retry: 2, // If request fails, retry up to two more times
- * 	},
+ * 	 { method: 'get' }, // fixed options cannot be overridden
+ * 	 { // default options can be overridden
+ * 	   headers: {
+ * 	   	Authorization: 'Bearer my-secret-token',
+ * 	   	'Content-Type': 'application/json',
+ * 	   },
+ * 	   timeout: 5000,
+ * 	 },
+ * 	 {// default defer options (can be overridden)
+ * 	   delay: 300,
+ * 	   retry: 2, // If request fails, retry up to two more times
+ * 	 },
  * )
  *
  * // Use it just like the standard fetch
  * apiClient('https://dummyjson.com/products/1', {
- * 	// The 'method' property cannot be overridden as it is used in the fixed options when creating the client.
- * 	// In TypeScript, the compiler will not allow this property.
- * 	// In Javascript, it will simply be ignored.
- * 	// method: 'post',
- * 	timeout: 3000, // The 'timeout' property can be overridden
+ *   // The 'method' property cannot be overridden as it is used in the fixed options when creating the client.
+ *   // In TypeScript, the compiler will not allow this property.
+ *   // In Javascript, it will simply be ignored.
+ *   // method: 'post',
+ *   timeout: 3000, // The 'timeout' property can be overridden
  * }).then(console.log, console.warn)
  *
  * // create a deferred client using "apiClient"
  * const deferredClient = apiClient.deferred(
- * 	{ retry: 0 }, // disable retrying by overriding the `retry` defer option
- * 	'https://dummyjson.com/products/1',
- * 	{ timeout: 3000 },
+ *   { retry: 0 }, // disable retrying by overriding the `retry` defer option
+ *   'https://dummyjson.com/products/1',
+ *   { timeout: 3000 },
  * )
  * deferredClient({ timeout: 10000 }) // timeout is overridden by individual request
  * 	.then(console.log, console.warn)
@@ -503,24 +517,25 @@ commonOptions?: FetchOptions & CommonOptions, commonDeferOptions?: DeferredAsync
  * Similar to `createClient`, the returned function comes equipped with a `.deferred()` method, enabling debounced,
  * throttled, or sequential execution.
  *
- * @example create reusable clients
+ * @example
+ * #### Create reusable clients
  * ```javascript
  * import { createPostClient, FetchAs } from '@superutils/fetch'
  *
  * // Create a POST client with 10-second as the default timeout
  * const postClient = createPostClient(
- * 	{
- * 		method: 'post',
- * 		headers: { 'content-type': 'application/json' },
+ * 	{ // fixed options cannot be overrided by client calls
+ * 	  method: 'post',
+ * 	  headers: { 'content-type': 'application/json' },
  * 	},
- * 	{ timeout: 10000 },
+ * 	{ timeout: 10000 }, // common options that can be overriden by client calls
  * )
  *
  * // Invoking `postClient()` automatically applies the pre-configured options
  * postClient(
- * 	'https://dummyjson.com/products/add',
- * 	{ title: 'New Product' }, // data/body
- * 	{}, // other options
+ * 	 'https://dummyjson.com/products/add',
+ * 	 { title: 'New Product' }, // data/body
+ * 	 {}, // other options
  * ).then(console.log)
  *
  * // create a deferred client using "postClient"
@@ -530,10 +545,7 @@ commonOptions?: FetchOptions & CommonOptions, commonDeferOptions?: DeferredAsync
  * 		onResult: console.log, // prints only successful results
  * 	},
  * 	'https://dummyjson.com/products/add',
- * 	{
- * 		method: 'patch',
- * 		timeout: 3000,
- * 	},
+ * 	{ method: 'patch', timeout: 3000 },
  * )
  * updateProduct({ title: 'New title 1' }) // ignored by debounce
  * updateProduct({ title: 'New title 2' }) // executed
@@ -574,12 +586,13 @@ declare const executeInterceptors: <T, TArgs extends unknown[]>(value: T, signal
  * @param options.as (optional) determines how to parse the result. Default: {@link FetchAs.json}
  * @param options.method (optional) fetch method. Default: `'get'`
  *
- * @example Make a simple HTTP requests
- * ```typescript
+ * @example
+ * #### Make a simple HTTP requests
+ * ```javascript
  * import { fetch } from '@superutils/fetch'
  *
  * // no need for `response.json()` or `result.data.data` drilling
- * fetch('https://dummyjson.com/products/1')
+ * fetch.get('https://dummyjson.com/products/1')
  * 	   .then(product => console.log(product))
  * ```
  */
@@ -594,10 +607,10 @@ declare const fetch$1: {
  *
  * Notes:
  * - item properties will be prioritized in the order of sequence they were passed in
- * - the following properties will be merged
- *     * `errMsgs`
- *     * `headers`
- *     * `interceptors`
+ * - the following properties will be merged:
+ *   * `errMsgs`
+ *   * `headers`
+ *   * `interceptors`
  * - all other properties will simply override previous values
  *
  * @returns combined
@@ -856,8 +869,8 @@ declare const methods: {
  * import fetch from '@superutils/fetch'
  *
  * fetch('https://dummyjson.com/products/1')
- *     .then(response => response.json())
- *     .then(console.log, console.error)
+ *   .then(response => response.json())
+ *   .then(console.log, console.error)
  * ```
  *
  * @example
@@ -867,13 +880,9 @@ declare const methods: {
  *
  * // 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))
- *
- *
+ *   .then(product => console.log(product))
  * fetch.post('https://dummyjson.com/products/add', { title: 'Product title' })
- *     .then(product => console.log(product))
+ *   .then(product => console.log(product))
  * ```
  *
  *
@@ -903,10 +912,10 @@ declare const methods: {
  *
  * // add an interceptor to conditionally include header before making requests
  * interceptors.request.push((url, options) => {
- * 		// ignore login requests
- *     if (`${url}`.includes('/login')) return
+ *   // ignore login requests
+ *   if (`${url}`.includes('/login')) return
  *
- *     options.headers.set('x-auth-token', 'my-auth-token')
+ *   options.headers.set('x-auth-token', 'my-auth-token')
  * })
  * ```
  */