@superutils/fetch 1.5.1 → 1.5.3

package/dist/index.d.ts

@@ -1,7 +1,8 @@
+import * as _superutils_core from '@superutils/core';
+import { ValueOrPromise, DropFirst } from '@superutils/core';
 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';
-import { ValueOrPromise, DropFirst } from '@superutils/core';
+export { DeferredAsyncOptions, OnEarlyFinalize, OnFinalize, ResolveError, ResolveIgnored, RetryIfFunc, RetryOptions, TIMEOUT_FALLBACK, TIMEOUT_MAX, TimeoutOptions, TimeoutPromise } from '@superutils/promise';
 
 /** Commonly used content types for easier access */
 declare const ContentType: {
@@ -44,34 +45,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 +85,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 +111,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 +150,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>;
@@ -263,7 +286,7 @@ type FetchCustomOptions = {
      * - Use `abortCtrl` instead of `signal` to prevent creating internal `AbortController` instance.
      */
     abortCtrl?: AbortController;
-    body?: PostBody | (() => PostBody);
+    body?: PostArgs[1];
     /**
      * Custom fetch function to use instead of the global `fetch`.
      * Useful for testing or using a different fetch implementation (e.g. `node-fetch` in older Node versions).
@@ -277,7 +300,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,16 +326,33 @@ 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' | 'body' | '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;
 };
 /**
  * Fetch options available to interceptors.
  *
  */
-type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'errMsgs' | 'interceptors' | 'headers' | 'timeout' | keyof FetchRetryOptions> & {
+type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'body' | 'errMsgs' | 'interceptors' | 'headers' | 'timeout' | keyof FetchRetryOptions> & {
     as: FetchAs;
+    body: PostBody;
     /** Error messages */
     errMsgs: Required<FetchErrMsgs>;
     headers: Headers;
@@ -350,7 +390,14 @@ type FetchRetryOptions = Omit<Partial<RetryOptions>, 'retry' | 'retryIf'> & {
 type PostBody = Record<string, unknown> | BodyInit | null;
 type PostArgs = [
     url: string | URL,
-    data?: PostBody | (() => PostBody),
+    /**
+     * Post body or a function that returns/resolves post body.
+     *
+     * PS:
+     * - if function provided, it will be executed before executing any request interceptors
+     * - if function execution fails it will throw an error and avoid making the fetch request
+     */
+    data?: PostBody | (() => ValueOrPromise<PostBody>),
     options?: PostOptions
 ];
 /**
@@ -360,30 +407,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 +467,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 +526,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 +554,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 +595,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 +616,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
@@ -703,7 +725,7 @@ declare const methods: {
             method: "delete";
         }, Options, DefaultOptions, ({
             headers?: HeadersInit | undefined;
-        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => _superutils_core.ValueOrPromise<PostBody>), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
     };
     /** Make HTTP requests with method PATCH */
     patch: {
@@ -728,7 +750,7 @@ declare const methods: {
             method: "patch";
         }, Options, DefaultOptions, ({
             headers?: HeadersInit | undefined;
-        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => _superutils_core.ValueOrPromise<PostBody>), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
     };
     /** Make HTTP requests with method POST */
     post: {
@@ -753,7 +775,7 @@ declare const methods: {
             method: "post";
         }, Options, DefaultOptions, ({
             headers?: HeadersInit | undefined;
-        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => _superutils_core.ValueOrPromise<PostBody>), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
     };
     /** Make HTTP requests with method PUT */
     put: {
@@ -778,7 +800,7 @@ declare const methods: {
             method: "put";
         }, Options, DefaultOptions, ({
             headers?: HeadersInit | undefined;
-        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
+        } & Omit<PostOptions, "headers" | "method"> & Partial<Record<"method", never>>) | undefined], T>>(...args: PostDeferredCbArgs<DefaultUrl, DefaultData, Options, [url: string | URL, data: PostBody | (() => _superutils_core.ValueOrPromise<PostBody>), options: PostOptions], undefined extends DefaultUrl ? DefaultUrl & undefined : DefaultUrl, undefined extends DefaultData ? DefaultData & undefined : DefaultData>) => IPromise_Fetch<TReturn>;
     };
 };
 /**
@@ -856,8 +878,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 +889,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 +921,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')
  * })
  * ```
  */