@superutils/fetch 1.0.3 → 1.1.1

package/README.md

@@ -20,7 +20,7 @@ This package enhances the native `fetch` API by providing a streamlined interfac
 - **Simplified API**: Automatically parses JSON responses, eliminating the need for `.then(res => res.json())`.
 - **Built-in Retries**: Automatic request retries with configurable exponential or fixed backoff strategies.
 - **Request Timeouts**: Easily specify a timeout for any request to prevent it from hanging indefinitely.
-- **Cancellable & Debounced Requests**: The `fetchDeferred` utility provides debouncing and throttling capabilities, automatically cancelling stale or intermediate requests. This is ideal for features like live search inputs.
+- **Cancellable & Debounced Requests**: The `fetch.METHOD.deferred()` utilities provide debouncing and throttling capabilities, automatically cancelling stale or intermediate requests. This is ideal for features like live search inputs.
 - **Interceptors**: Hook into the request/response lifecycle to globally modify requests, handle responses, or manage errors.
 - **Strongly Typed**: Written in TypeScript for excellent autocompletion and type safety.
 - **Isomorphic**: Works seamlessly in both Node.js and browser environments.
@@ -42,13 +42,13 @@ Make a simple GET request. No need for `response.json()` or `result.data.theActu
 ```typescript
 import fetch from '@superutils/fetch'
 
-const theActualData = await fetch('https://dummyjson.com/products/1', {
+fetch('https://dummyjson.com/products/1', {
 	method: 'get', // default
-})
-console.log(theActualData)
+}).then(theActualData => console.log(theActualData))
 // Alternative:
-const theActualData2 = await fetch.get('https://dummyjson.com/products/1')
-console.log(theActualData2)
+fetch
+	.get('https://dummyjson.com/products/1')
+	.then(theActualData => console.log(theActualData))
 ```
 
 <div id="methods"></div>
@@ -81,13 +81,13 @@ While `fetch()` provides access to all HTTP request methods by specifying it in
 
 A practical utility that combines `PromisE.deferred()` from the `@superutils/promise` package with `fetch()`. It's perfect for implementing cancellable, debounced, or throttled search inputs.
 
-```typescript
-import fetch, { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
+```javascript
+import fetch from '@superutils/fetch'
 
 // Create a debounced search function with a 300ms delay.
 const searchProducts = fetch.get.deferred({
 	delayMs: 300, // Debounce delay
-	resolveIgnored: ResolveIgnored.WITH_UNDEFINED, // Ignored (aborted) promises will resolve with `undefined`
+	resolveIgnored: 'WITH_UNDEFINED', // Ignored (aborted) promises will resolve with `undefined`
 })
 
 // User types 'iphone'
@@ -97,34 +97,34 @@ searchProducts('https://dummyjson.com/products/search?q=iphone').then(
 	},
 )
 
-// Before 300ms has passed, the user continues typing 'iphone 9'
+// Before 300ms has passed, the user continues typing 'iphone 12'
 setTimeout(() => {
-	searchProducts('https://dummyjson.com/products/search?q=iphone 9').then(
+	searchProducts('https://dummyjson.com/products/search?q=iphone 12').then(
 		result => {
-			console.log('Result for "iphone 9":', result)
+			console.log('Result for "iphone 12":', 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.
+// The second request for "iphone 12" is executed after the 300ms debounce delay.
 ```
 
 **Behavior with different `deferOptions` in the example above:**
 
 - **`throttle: true`**: Switches from debounce to throttle mode. The first request for "iphone" would
-  execute immediately. The second request for "iphone 9", made within the 300ms throttle window, would be ignored.
+  execute immediately. The second request for "iphone 12", made within the 300ms throttle window, would be ignored.
 - **`delayMs: 0`**: Disables debouncing and throttling, enabling sequential/queue mode. Both requests ("iphone"
-  and "iphone 9") would execute, but one after the other, never simultaneously.
-- **`resolveIgnored`**: Controls how the promise for an aborted request (like the first "iphone" call) resolves.
+  and "iphone 12") would execute, but one after the other, never simultaneously.
+- **`resolveIgnored` (enum)**: Controls how the promise for an aborted request (like the first "iphone" call) resolves.
     1. `ResolveIgnored.WITH_UNDEFINED` (used in the example): The promise for the aborted "iphone"
        request resolves with `undefined`.
     2. `ResolveIgnored.WITH_LAST`: The promise for the aborted "iphone" request waits and resolves with the result
-       of the final "iphone 9" request. Both promises resolve to the same value.
+       of the final "iphone 12" request. Both promises resolve to the same value.
     3. `ResolveIgnored.NEVER`: The promise for the aborted "iphone" request is neither resolved nor rejected.
        It will remain pending indefinitely.
-- **`resolveError`**: Controls how failed requests are handled.
+- **`resolveError` (enum)**: Controls how failed requests are handled.
     1.  `ResolveError.NEVER`: Never resolve ignored promises. Caution: make sure this doesn't cause any memory leaks.
     2.  `ResolveError.WITH_LAST`: (default) resolve with active promise result, the one that caused the current promise/callback to be ignored.
     3.  `ResolveError.WITH_UNDEFINED`: resolve failed requests with `undefined` value
@@ -132,8 +132,8 @@ setTimeout(() => {
 
 #### Using defaults to reduce redundancy
 
-```typescript
-import fetch, { ResolveIgnored } from '@superutils/fetch'
+```javascript
+import fetch 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.
@@ -142,16 +142,16 @@ const getRandomQuote = fetch.get.deferred(
 		delayMs: 300, // Throttle window
 		throttle: true,
 		// Ignored calls will resolve with the result of the last successful call.
-		resolveIgnored: ResolveIgnored.WITH_LAST,
+		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))
+getRandomQuote().then(quote => console.log('Call 1 resolved:', quote))
+getRandomQuote().then(quote => console.log('Call 2 resolved:', quote))
+getRandomQuote().then(quote => console.log('Call 3 resolved:', quote))
 
 // Outcome:
 // Due to throttling, only one network request is made.
@@ -197,19 +197,19 @@ const saveProductThrottled = fetch.post.deferred(
 		trailing: true, // Ensures the very last update is always saved
 		onResult: product => console.log(`[Saved] Product: ${product.title}`),
 	},
-	'https://dummyjson.com/products/1', // Default URL
-	undefined, // No default data
-	{ method: 'put' }, // Default method
+	'https://dummyjson.com/products/add', // Default URL
 )
 // Simulate a user typing quickly, triggering multiple saves.
 console.log('User starts typing...')
-saveProductThrottled({ title: 'iPhone' }) // Executed immediately (leading edge)
-await PromisE.delay(200)
-saveProductThrottled({ title: 'iPhone 15' }) // Ignored (within 1000ms throttle window)
-await PromisE.delay(300)
-saveProductThrottled({ title: 'iPhone 15 Pro' }) // Ignored
-await PromisE.delay(400)
-saveProductThrottled({ title: 'iPhone 15 Pro Max' }) // Queued to execute on the trailing edge
+
+// 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.
@@ -231,11 +231,11 @@ let currentRefreshToken = ''
 const requestNewToken = fetch.post.deferred(
 	{
 		delayMs: 300, // debounce delay
-		onResult: ({ token = '' }) => {
+		onResult: ({ refreshToken = '' }) => {
 			console.log(
 				`Auth token successfully refreshed at ${new Date().toISOString()}`,
 			)
-			currentRefreshToken = token
+			currentRefreshToken = refreshToken
 		},
 	},
 	'https://dummyjson.com/auth/refresh', // Default URL

package/dist/index.d.ts

@@ -282,6 +282,7 @@ type PostArgs<OmitMethod = false> = [
     options?: OmitMethod extends true ? Omit<FetchOptions, 'method'> : PostOptions
 ];
 /**
+ * Dynamic arguments for deffered post-like methods.
  *
  * @example
  * ```typescript
@@ -311,7 +312,7 @@ type PostArgs<OmitMethod = false> = [
  * f4().then(console.log, console.warn)
  * ```
  */
-type PostDeferredCallbackArgs<TUrl = undefined, TData = undefined, OmitMethod extends boolean = true, CbArgs extends PostArgs<OmitMethod> = PostArgs<OmitMethod>, Options = CbArgs[2], RPA extends unknown[] = Required<CbArgs>> = [TUrl, TData] extends [RPA[0], undefined] ? [data?: CbArgs[1], options?: Options] : [TUrl, TData] extends [undefined, RPA[1]] ? [url: CbArgs[0], options?: Options] : [TUrl, TData] extends [RPA[0], RPA[1]] ? [options?: Options] : CbArgs;
+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'> & {
     /** Default: `'post'` */
     method?: 'post' | 'put' | 'patch' | 'delete' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
@@ -333,7 +334,7 @@ declare const fetch$1: {
  *
  * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
  * See {@link DeferredAsyncOptions} for details.
- * @param globalUrl (optional) If a global URL is `undefined`, returned callback will always require an URL.
+ * @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.
@@ -366,20 +367,6 @@ declare const fetch$1: {
  * // The second request for "iphone 9" is executed after the 300ms debounce delay.
  * ```
  *
- * **Behavior with different `deferOptions` in the example above:**
- * - **`throttle: true`**: Switches from debounce to throttle mode. The first request for "iphone" would
- * execute immediately. The second request for "iphone 9", made within the 300ms throttle window, would be ignored.
- * - **`delayMs: 0`**: Disables debouncing and throttling, enabling sequential/queue mode. Both requests ("iphone"
- * and "iphone 9") would execute, but one after the other, never simultaneously.
- * - **`resolveIgnored`**: Controls how the promise for an aborted request (like the first "iphone" call) resolves.
- *    1. `ResolveIgnored.WITH_UNDEFINED` (used in the example): The promise for the aborted "iphone"
- * request resolves with `undefined`.
- *    2. `ResolveIgnored.WITH_LAST`: The promise for the aborted "iphone" request waits and resolves with the result
- * of the final "iphone 9" request. Both promises resolve to the same value.
- *    3. `ResolveIgnored.NEVER`: The promise for the aborted "iphone" request is neither resolved nor rejected.
- * It will remain pending indefinitely.
- *    4. `ResolveIgnored.WITH_ERROR`: The promise for the aborted "iphone" request is rejected with a `FetchError`.
- *
  * @example Creating a reusable, pre-configured client
  * ```typescript
  * import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
@@ -409,7 +396,7 @@ declare const fetch$1: {
  * // Console output will show the same quote ID for all three calls.
  * ```
  */
-declare function fetchDeferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = FetchArgs[0] | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: FetchArgs<true>[1]]>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, defaultOptions?: FetchArgs[1]): <TResult = unknown>(...args: CbArgs) => _superutils_promise.IPromisE<TResult>;
+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
@@ -423,8 +410,8 @@ declare function fetchDeferred<ThisArg = unknown, Delay extends number = number,
  *
  * @param deferOptions Configuration for the deferred execution behavior (e.g., `delayMs`, `throttle`).
  * See {@link DeferredAsyncOptions} for details.
- * @param globalUrl (optional) If global URL is `undefined`, returned callback will always require an URL.
- * @param globalData (optional) If global data is `undefined`, returned callback will allow a data parameter.
+ * @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.
@@ -510,7 +497,7 @@ declare function fetchDeferred<ThisArg = unknown, Delay extends number = number,
  * // The token is refreshed only once, preventing redundant network requests.
  * ```
  */
-declare function postDeferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, Args extends unknown[] = PostDeferredCallbackArgs<GlobalUrl, GlobalData, true>>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, globalData?: GlobalData, defaultOptions?: PostArgs[2]): <TResult = unknown>(...args: Args) => _superutils_promise.IPromisE<TResult>;
+declare function postDeferred<ThisArg, Delay extends number = number, 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}
@@ -528,34 +515,43 @@ declare function postDeferred<ThisArg, Delay extends number = number, GlobalUrl
  */
 declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptionsInterceptor;
 
-type FetchWithoutMethods = typeof fetch$1;
+/** Create a method-specific fetch function attached with a `.deferred()` function */
+declare const createFetchMethodFunc: (method?: string) => {
+    <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+};
+/** Create a method-specific function for POST-like methods and with a `.deferred()` function */
+declare const createPostMethodFunc: (method?: Pick<PostOptions, "method">["method"]) => {
+    <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
+};
 declare const _get: {
     <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number, GlobalUrl extends string | URL>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay> | undefined, globalUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined) => <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _head: {
     <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number, GlobalUrl extends string | URL>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay> | undefined, globalUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined) => <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _options: {
     <T>(url: string | URL, options?: Omit<FetchOptions, "method">): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number, GlobalUrl extends string | URL>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay> | undefined, globalUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined) => <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg = unknown, Delay extends number = number, GlobalUrl = string | URL | undefined, CbArgs extends unknown[] = undefined extends GlobalUrl ? FetchArgs<true> : [options?: Omit<FetchOptions, "method"> | undefined]>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultOptions?: FetchOptions | undefined): <TResult = unknown>(...args: undefined extends GlobalUrl ? FetchArgs<false> : [options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _delete: {
     <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number = number, Args extends PostArgs<true> = PostArgs<true>, GlobalUrl extends Args[0] | undefined = undefined, GlobalData extends Args[1] | undefined = undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, globalData?: GlobalData, defaultOptions?: Args[2]) => <TResult = unknown>(...args: PostDeferredCallbackArgs<GlobalUrl, GlobalData, true, PostArgs<true>, Omit<FetchOptions, "method"> | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: Omit<FetchOptions, "method">]>) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _patch: {
     <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number = number, Args extends PostArgs<true> = PostArgs<true>, GlobalUrl extends Args[0] | undefined = undefined, GlobalData extends Args[1] | undefined = undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, globalData?: GlobalData, defaultOptions?: Args[2]) => <TResult = unknown>(...args: PostDeferredCallbackArgs<GlobalUrl, GlobalData, true, PostArgs<true>, Omit<FetchOptions, "method"> | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: Omit<FetchOptions, "method">]>) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _post: {
     <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number = number, Args extends PostArgs<true> = PostArgs<true>, GlobalUrl extends Args[0] | undefined = undefined, GlobalData extends Args[1] | undefined = undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, globalData?: GlobalData, defaultOptions?: Args[2]) => <TResult = unknown>(...args: PostDeferredCallbackArgs<GlobalUrl, GlobalData, true, PostArgs<true>, Omit<FetchOptions, "method"> | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: Omit<FetchOptions, "method">]>) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
 };
 declare const _put: {
     <T, Args extends PostArgs<true> = PostArgs<true>>(url: Args[0], data?: Args[1], options?: Args[2]): _superutils_promise.IPromisE<T>;
-    deferred: <ThisArg, Delay extends number = number, Args extends PostArgs<true> = PostArgs<true>, GlobalUrl extends Args[0] | undefined = undefined, GlobalData extends Args[1] | undefined = undefined>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, globalData?: GlobalData, defaultOptions?: Args[2]) => <TResult = unknown>(...args: PostDeferredCallbackArgs<GlobalUrl, GlobalData, true, PostArgs<true>, Omit<FetchOptions, "method"> | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: Omit<FetchOptions, "method">]>) => _superutils_promise.IPromisE<TResult>;
+    deferred<ThisArg, Delay extends number = number, GlobalUrl extends PostArgs[0] | undefined = undefined, GlobalData extends PostArgs[1] | undefined = undefined, CbArgs extends unknown[] = PostDeferredCbArgs<GlobalUrl, GlobalData, true>>(deferOptions?: _superutils_promise.DeferredAsyncOptions<ThisArg, Delay> | undefined, defaultUrl?: GlobalUrl | undefined, defaultData?: GlobalData | undefined, defaultOptions?: PostOptions | undefined): <TResult = unknown>(...args: PostDeferredCbArgs<GlobalUrl, GlobalData, false, PostArgs<false>, PostOptions | undefined, [url: string | URL, data: PostBody | (() => PostBody), options: PostOptions]>) => _superutils_promise.IPromisE<TResult>;
 };
 /**
  * @function fetch
@@ -606,6 +602,8 @@ declare const _put: {
  * Options' default values (excluding `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
  *
  * ```typescript
+ * import fetch from '@superutils/fetch'
+ *
  * fetch.defaults = {
  *     as: FetchAs.json,
  *     errMsgs: {
@@ -622,15 +620,16 @@ declare const _put: {
  *     	   result: [],
  *     },
  *     timeout: 0,
- *     ........
+ *     //........
  * }
  * ```
- * @param options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
- * @param options.headers (optional) request headers. Default: `{ 'content-type' : 'application/json'}`
- * @param options.interceptors (optional) request interceptor callbacks.  See {@link FetchInterceptors} for details.
- * @param options.method  (optional) Default: `"get"`
- * @param options.timeout (optional) duration in milliseconds to abort the request if it takes longer.
- * @param options.parse   (optional) specify how to parse the result.
+ *
+ * @property options.abortCtrl (optional) if not provided `AbortController` will be instantiated when `timeout` used.
+ * @property options.headers (optional) request headers. Default: `{ 'content-type' : 'application/json'}`
+ * @property options.interceptors (optional) request interceptor callbacks.  See {@link FetchInterceptors} for details.
+ * @property options.method (optional) Default: `"get"`
+ * @property options.timeout (optional) duration in milliseconds to abort the request if it takes longer.
+ * @property options.parse (optional) specify how to parse the result.
  * Default: {@link FetchAs.json}
  * For raw `Response` use {@link FetchAs.response}
  *
@@ -643,13 +642,13 @@ declare const _put: {
  * ```
  */
 declare const fetch: typeof fetch$1 & {
+    delete: typeof _delete;
     get: typeof _get;
     head: typeof _head;
     options: typeof _options;
-    delete: typeof _delete;
     patch: typeof _patch;
     post: typeof _post;
     put: typeof _put;
 };
 
-export { type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type FetchWithoutMethods, type Interceptor, type PostArgs, type PostBody, type PostDeferredCallbackArgs, type PostOptions, fetch as default, fetch, fetchDeferred, mergeFetchOptions, postDeferred };
+export { type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchCustomOptions, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type Interceptor, type PostArgs, type PostBody, type PostDeferredCbArgs, type PostOptions, createFetchMethodFunc, createPostMethodFunc, fetch as default, fetch, fetchDeferred, mergeFetchOptions, postDeferred };

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/fetch.ts
 import {
+  fallbackIfFails as fallbackIfFails2,
   isEmpty as isEmpty2,
   isFn as isFn2,
   isPositiveNumber,
@@ -90,6 +91,10 @@ var mergeFetchOptions = (...allOptions) => allOptions.reduce(
 var mergeFetchOptions_default = mergeFetchOptions;
 
 // src/types.ts
+import {
+  ResolveError,
+  ResolveIgnored
+} from "@superutils/promise";
 var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
   FetchAs2["arrayBuffer"] = "arrayBuffer";
   FetchAs2["blob"] = "blob";
@@ -147,7 +152,13 @@ var fetch = (url, options = {}) => {
       const { status = 0 } = response;
       const isSuccess = status >= 200 && status < 300;
       if (!isSuccess) {
-        const jsonError = await response.json();
+        const jsonError = await fallbackIfFails2(
+          // try to parse error response as json first
+          () => response.json(),
+          [],
+          // fallback to text if json parsing fails
+          `Request failed with status code: ${status}`
+        );
         const message = (jsonError == null ? void 0 : jsonError.message) || `${errMsgs.requestFailed} ${status}.`;
         throw new Error(`${message}`.replace("Error: ", ""), {
           cause: jsonError
@@ -223,23 +234,17 @@ var fetch_default = fetch;
 
 // src/fetchDeferred.ts
 import PromisE3 from "@superutils/promise";
-import {
-  ResolveError,
-  ResolveIgnored
-} from "@superutils/promise";
-function fetchDeferred(deferOptions = {}, globalUrl, defaultOptions) {
+function fetchDeferred(deferOptions = {}, defaultUrl, defaultOptions) {
   let _abortCtrl;
   const fetchCallback = (...args) => {
     var _a, _b, _c;
-    let options = {
-      ...(_a = globalUrl === void 0 ? args[1] : args[0]) != null ? _a : {}
-    };
+    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(
-      globalUrl != null ? globalUrl : args[0],
+      defaultUrl != null ? defaultUrl : args[0],
       options
     );
     promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
@@ -268,23 +273,21 @@ function post(...[url = "", data, options = {}]) {
 }
 
 // src/postDeferred.ts
-import {
-  ResolveError as ResolveError2,
-  ResolveIgnored as ResolveIgnored2
-} from "@superutils/promise";
-function postDeferred(deferOptions = {}, globalUrl, globalData, defaultOptions) {
+function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions) {
   let _abortCtrl;
   const doPost = (...args) => {
     var _a, _b, _c;
-    if (globalUrl !== void 0) args.splice(0, 0, globalUrl);
-    if (globalData !== void 0) args.splice(1, 0, globalData);
-    const url = args[0];
-    const data = args[1];
+    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(url, data, options);
+    const promise = post(
+      args[0],
+      args[1],
+      options
+    );
     promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
     return promise;
   };
@@ -294,32 +297,31 @@ var postDeferred_default = postDeferred;
 
 // src/index.ts
 var createFetchMethodFunc = (method = "get") => {
-  const deferred = (...args) => fetchDeferred_default(...args);
   const methodFunc = (url, options) => {
     options != null ? options : options = {};
     options.method = method;
     return fetch_default(url, options);
   };
-  methodFunc.deferred = deferred;
+  methodFunc.deferred = (...args) => {
+    var _a;
+    (_a = args[2]) != null ? _a : args[2] = {};
+    args[2].method = method;
+    return fetchDeferred_default(...args);
+  };
   return methodFunc;
 };
 var createPostMethodFunc = (method = "post") => {
-  const deferredFunc = (deferOptions = {}, globalUrl, globalData, defaultOptions) => {
-    defaultOptions != null ? defaultOptions : defaultOptions = {};
-    defaultOptions.method = method;
-    return postDeferred_default(
-      deferOptions,
-      globalUrl,
-      globalData,
-      defaultOptions
-    );
-  };
   const methodFunc = (url, data, options) => {
     options != null ? options : options = {};
     options.method = method;
     return post(url, data, options);
   };
-  methodFunc.deferred = deferredFunc;
+  methodFunc.deferred = (...args) => {
+    var _a;
+    (_a = args[3]) != null ? _a : args[3] = {};
+    args[3].method = method;
+    return postDeferred_default(...args);
+  };
   return methodFunc;
 };
 var _get = createFetchMethodFunc("get");
@@ -330,10 +332,10 @@ var _patch = createPostMethodFunc("patch");
 var _post = createPostMethodFunc("post");
 var _put = createPostMethodFunc("put");
 var fetch2 = fetch_default;
+fetch2.delete = _delete;
 fetch2.get = _get;
 fetch2.head = _head;
 fetch2.options = _options;
-fetch2.delete = _delete;
 fetch2.patch = _patch;
 fetch2.post = _post;
 fetch2.put = _put;
@@ -341,6 +343,10 @@ var index_default = fetch2;
 export {
   FetchAs,
   FetchError,
+  ResolveError,
+  ResolveIgnored,
+  createFetchMethodFunc,
+  createPostMethodFunc,
   index_default as default,
   fetch2 as fetch,
   fetchDeferred,

package/package.json

@@ -5,8 +5,8 @@
 	},
 	"description": "A lightweight `fetch` wrapper for browsers and Node.js, designed to simplify data fetching and reduce boilerplate.",
 	"dependencies": {
-		"@superutils/core": "^1.0.8",
-		"@superutils/promise": "^1.0.9"
+		"@superutils/core": "^1.1.1",
+		"@superutils/promise": "^1.1.1"
 	},
 	"files": [
 		"dist",
@@ -24,8 +24,8 @@
 	"main": "dist/index.js",
 	"name": "@superutils/fetch",
 	"peerDependencies": {
-		"@superutils/core": "^1.0.8",
-		"@superutils/promise": "^1.0.9"
+		"@superutils/core": "^1.1.1",
+		"@superutils/promise": "^1.1.1"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -45,5 +45,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.0.3"
+	"version": "1.1.1"
 }