@superutils/fetch 0.1.0 → 1.0.1

package/README.md

@@ -9,8 +9,11 @@ This package enhances the native `fetch` API by providing a streamlined interfac
 - Features
 - Installation
 - Usage
-    - `fetch(url, options)`
-    - `fetchDeferred(deferOptions, url, fetchOptions)`
+    - [`fetch()`](#fetch): make HTTP requests just like built-in `fetch()`
+    - [`Method Specific Functions`](#methods)
+    - [`fetchDeferred()`](#fetch-deferred): cancellable and debounced or throttled `fetch()`
+    - [`post()`](#post): make post-like requests
+    - [`postDeferred()`](#post-deferred) cancellable and debounced or throttled `post()`
 
 ## Features
 
@@ -37,23 +40,52 @@ npm install @superutils/fetch
 Make a simple GET request. No need for `response.json()` or `result.data.theActualData` drilling.
 
 ```typescript
-import { fetch } from '@superutils/fetch'
+import fetch from '@superutils/fetch'
 
-const theActualData = await fetch('https://dummyjson.com/products/1')
+const theActualData = await fetch('https://dummyjson.com/products/1', {
+	method: 'get', // default
+})
+console.log(theActualData)
+// Alternative:
+const theActualData = await fetch.get('https://dummyjson.com/products/1')
 console.log(theActualData)
 ```
 
-<div id="fetchDeferred"></div>
+<div id="methods"></div>
+
+### Method Specific Functions
+
+While `fetch()` provides access to all HTTP request methods by specifying it in options (eg: `{ method: 'get' }`), for ease of use you can also use the following:
+
+- `fetch.delete(...)`
+- `fetch.get(...)`
+- `fetch.head(...)`
+- `fetch.options(...)`
+- `fetch.patch(...)`
+- `fetch.post(...)`
+- `fetch.put(...)`
 
-### `fetchDeferred(deferOptions, url, fetchOptions)`
+**Deferred variants:** To debounce/throttle requests.
+
+- `fetch.delete.deferred(...)`
+- `fetch.get.deferred(...)`
+- `fetch.head.deferred(...)`
+- `fetch.options.deferred(...)`
+- `fetch.patch.deferred(...)`
+- `fetch.post.deferred(...)`
+- `fetch.put.deferred(...)`
+
+<div id="fetch-deferred"></div>
+
+### `fetch.get.deferred(deferOptions, defaultUrl, defaultOptions)`
 
 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 { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
+import fetch, { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
 
 // Create a debounced search function with a 300ms delay.
-const searchProducts = fetchDeferred({
+const searchProducts = fetch.get.deferred({
 	delayMs: 300, // Debounce delay
 	resolveIgnored: ResolveIgnored.WITH_UNDEFINED, // Ignored (aborted) promises will resolve with `undefined`
 })
@@ -97,11 +129,11 @@ setTimeout(() => {
 #### Using defaults to reduce redundancy
 
 ```typescript
-import { fetchDeferred, ResolveIgnored } from '@superutils/fetch'
+import fetch, { 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(
+const getRandomQuote = fetch.get.deferred(
 	{
 		delayMs: 300, // Throttle window
 		throttle: true,
@@ -126,8 +158,10 @@ getRandomQuote().then(quote => console.log('Call 3 resolved:', quote.id))
 
 <div id="post"></div>
 
-### `post(url, options)`
+### `fetch.post(url, options)`
+
+<div id="post-deferred"></div>
 
-<div id="postDeferred"></div>
+### `fetch.post.deferred(deferOptions, url, postOptions)`
 
-### `postDeferred(deferOptions, url, postOptions)`
+<div id="method-specific"></div>

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _superutils_promise from '@superutils/promise';
-import { RetryOptions, Config as Config$1, IPromisE, DeferredOptions } from '@superutils/promise';
-export { DeferredOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
+import { RetryOptions, IPromisE, DeferredAsyncOptions } from '@superutils/promise';
+export { DeferredAsyncOptions, ResolveError, ResolveIgnored } from '@superutils/promise';
 import { ValueOrPromise } from '@superutils/core';
 
 type FetchArgs = [url: string | URL, options?: FetchOptions];
@@ -17,7 +17,8 @@ declare enum FetchAs {
     response = "response",
     text = "text"
 }
-type FetchConf = {
+/** Custom fetch options (not used by built-in `fetch()`*/
+type FetchCustomOptions = {
     /**
      * Specify how the parse the result. To get raw response use {@link FetchAs.response}.
      * Default: 'json'
@@ -28,7 +29,7 @@ type FetchConf = {
     interceptors?: FetchInterceptors;
     /** Request timeout in milliseconds. */
     timeout?: number;
-};
+} & FetchRetryOptions;
 /** Default args */
 type FetchDeferredArgs = [
     url?: string | URL,
@@ -230,7 +231,8 @@ type FetchInterceptors = {
 /**
  * Fetch request options
  */
-type FetchOptions = RequestInit & FetchConf & FetchRetryOptions;
+type FetchOptions = RequestInit & FetchCustomOptions;
+type FetchOptionsDefaults = Omit<FetchOptionsInterceptor, 'method' | 'retryIf'>;
 /**
  * Fetch options available to interceptors
  */
@@ -239,7 +241,7 @@ type FetchOptionsInterceptor = Omit<FetchOptions, 'as' | 'errMsgs' | 'intercepto
     errMsgs: Required<FetchErrMsgs>;
     headers: Headers;
     interceptors: Required<FetchInterceptors>;
-} & Required<FetchRetryOptions>;
+} & FetchRetryOptions;
 /**
  * Result types for specific parsers ("as": FetchAs)
  */
@@ -255,7 +257,7 @@ interface FetchResult<T> {
 /**
  * Fetch retry options
  */
-type FetchRetryOptions = Partial<RetryOptions> & {
+type FetchRetryOptions = Omit<Partial<RetryOptions>, 'retry' | 'retryIf'> & {
     /**
      * Maximum number of retries.
      *
@@ -264,6 +266,7 @@ type FetchRetryOptions = Partial<RetryOptions> & {
      * Default: `0`
      */
     retry?: number;
+    retryIf?: null | ((response: Response | undefined, retryCount: number, error?: unknown) => boolean | Promise<boolean>);
 };
 /**
  * Generic fetch interceptor type
@@ -273,44 +276,49 @@ type PostBody = Record<string, unknown> | BodyInit | null;
 type PostArgs = [
     url: string | URL,
     data?: PostBody,
-    options?: Omit<FetchOptions, 'method'> & {
-        /** Default: `'post'` */
-        method?: 'post' | 'put' | 'patch' | 'delete';
-    }
+    options?: PostOptions
 ];
-
-type Config = Config$1 & {
-    fetchOptions: FetchOptionsInterceptor;
-};
-declare const config: Config;
-
 /**
- * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
- * and powerful interceptors. It also includes deferred and throttled request capabilities for complex asynchronous
- * control flows.
- *
- * Will reject promise if response status code is not 2xx (200 <= status < 300).
- *
- * @param	url
- * @param options (optional) all built-in `fetch()` options such as "method", "headers" and the additionals below.
- * @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.
- * Default: {@link FetchAs.json}
- * For raw `Response` use {@link FetchAs.response}
  *
- * @example Make a simple HTTP requests
+ * @example
  * ```typescript
- * import { fetch } from '@superutils/fetch'
- *
- * // no need for `response.json()` or `result.data.theActualData` drilling
- * fetch('https://dummyjson.com/products/1').then(theActualData => console.log(theActualData))
+ * // 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]
+ *
+ * const data = { name: 'test' }
+ * const url = 'https://domain.com'
+ * // test with postDeferred()
+ * const f1 = postDeferred({}, 'https://domain.com')
+ * // expected: [data, options]
+ * f1({data: 1}).then(console.log, console.warn)
+ *
+ * const f2 = postDeferred({}, undefined, 'dome data')
+ * // expected: [url, options]
+ * f2('https').then(console.log, console.warn)
+ *
+ * const f3 = postDeferred({})
+ * // expected: [url, data, options]
+ * f3('https://domain.com').then(console.log, console.warn)
+ *
+ * const f4 = postDeferred({}, 'url', 'data')
+ * // expected: [options]
+ * f4().then(console.log, console.warn)
  * ```
  */
-declare function fetch$1<TJSON, TOptions extends FetchOptions = FetchOptions, TReturn = TOptions['as'] extends FetchAs ? FetchResult<TJSON>[TOptions['as']] : TJSON>(url: string | URL, options?: TOptions): IPromisE<TReturn>;
+type PostDeferredCallbackArgs<TUrl = undefined, TData = undefined, RPA extends unknown[] = Required<PostArgs>> = [TUrl, TData] extends [RPA[0], undefined] ? [data?: PostArgs[1], options?: PostArgs[2]] : [TUrl, TData] extends [undefined, RPA[1]] ? [url: PostArgs[0], options?: PostArgs[2]] : [TUrl, TData] extends [RPA[0], RPA[1]] ? [options?: PostArgs[2]] : PostArgs;
+type PostOptions = Omit<FetchOptions, 'method'> & {
+    /** Default: `'post'` */
+    method?: 'post' | 'put' | 'patch' | 'delete';
+};
+
+declare const fetch$1: {
+    <T, TOptions extends FetchOptions = FetchOptions, TReturn = TOptions["as"] extends FetchAs ? FetchResult<T>[TOptions["as"]] : T>(url: string | URL, options?: TOptions): IPromisE<TReturn>;
+    /** Default fetch options */
+    defaults: FetchOptionsDefaults;
+};
 
 /**
  * Creates a deferred/throttled version of {@link fetch}, powered by {@link PromisE.deferred}.
@@ -321,10 +329,11 @@ declare function fetch$1<TJSON, TOptions extends FetchOptions = FetchOptions, TR
  * `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 DeferredOptions} for details.
- * @param defaultFetchArgs (optional) Default `url` and `fetchOptions` to be used for every call made by the
- * returned function. This is useful for creating a reusable client for a specific endpoint.
- *
+ * See {@link DeferredAsyncOptions} for details.
+ * @param globalUrl (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
@@ -397,7 +406,7 @@ declare function fetch$1<TJSON, TOptions extends FetchOptions = FetchOptions, TR
  * // Console output will show the same quote ID for all three calls.
  * ```
  */
-declare function fetchDeferred<ThisArg, DefaultUrl extends string | URL>(deferOptions?: DeferredOptions<ThisArg>, defaultUrl?: DefaultUrl, defaultOptions?: FetchDeferredArgs[1]): <TResult = unknown>(...args: DefaultUrl extends undefined ? FetchArgs : [url?: string | URL | undefined, options?: FetchOptions | undefined]) => _superutils_promise.IPromisE<TResult>;
+declare function fetchDeferred<ThisArg = unknown, Delay extends number = number, GlobalUrl extends string | URL | undefined = string | URL | undefined, Args extends unknown[] = undefined extends GlobalUrl ? FetchArgs : [options?: FetchOptions]>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, defaultOptions?: FetchDeferredArgs[1]): <TResult = unknown>(...args: Args) => _superutils_promise.IPromisE<TResult>;
 
 /**
  * Creates a deferred/throttled function for making `POST`, `PUT`, or `PATCH` requests, powered by
@@ -408,6 +417,16 @@ declare function fetchDeferred<ThisArg, DefaultUrl extends string | URL>(deferOp
  * 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 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 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 Debouncing an authentication token refresh
  * ```typescript
  * import { postDeferred } from '@superutils/fetch'
@@ -485,12 +504,12 @@ declare function fetchDeferred<ThisArg, DefaultUrl extends string | URL>(deferOp
  * // This results in only two network requests instead of four.
  * ```
  */
-declare function postDeferred<ThisArg, DefaultUrl extends string | URL>(deferOptions?: DeferredOptions<ThisArg>, defaultUrl?: DefaultUrl, defaultData?: PostArgs[1], defaultOptions?: PostArgs[2]): <TResult = unknown>(...args: DefaultUrl extends undefined ? PostArgs : [url?: string | URL | undefined, data?: PostBody | undefined, options?: (Omit<FetchOptions, "method"> & {
-    method?: "post" | "put" | "patch" | "delete";
-}) | undefined]) => _superutils_promise.IPromisE<TResult>;
+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>>(deferOptions?: DeferredAsyncOptions<ThisArg, Delay>, globalUrl?: GlobalUrl, // The default URL for all calls
+globalData?: GlobalData, // The default data for all calls
+defaultOptions?: PostOptions): <TResult = unknown>(...args: Args) => _superutils_promise.IPromisE<TResult>;
 
 /**
- * Merge one or more {@link FetchOptions} with global fetch options ({@link config.fetchOptions}).
+ * Merge one or more {@link FetchOptions}
  *
  * Notes:
  * - {@link config.fetchOptions} will be added as the base and not necessary to be included
@@ -505,16 +524,109 @@ declare function postDeferred<ThisArg, DefaultUrl extends string | URL>(deferOpt
  */
 declare const mergeFetchOptions: (...allOptions: FetchOptions[]) => FetchOptionsInterceptor;
 
-type Func = <T, Options extends Omit<FetchOptions, 'method'>>(url: string | URL, options?: Options) => ReturnType<typeof fetch$1<T, Options>>;
-type MethodFunc = Func & ({
+type FetchWithoutMethods = typeof fetch$1;
+/** Describes method-specific fetch-functions that includes `.deferred()` function for deferred/throttled requests */
+type FetchMethodFunc = (<T, Options extends Omit<FetchOptions, 'method'>>(url: string | URL, options?: Options) => ReturnType<typeof fetch$1<T, Options>>) & {
     deferred: typeof fetchDeferred;
-} | {
+};
+/** Describes method-specific fetch-functions that includes `.deferred()` function for deferred/throttled requests */
+type PostMethodFunc = (<T, Options extends Omit<FetchOptions, 'method'>>(url: string | URL, data?: PostBody, options?: Options) => ReturnType<typeof fetch$1<T, Options>>) & {
     deferred: typeof postDeferred;
-});
-type FetchDeferred = typeof fetchDeferred | typeof postDeferred;
-interface DefaultFetch extends Record<string, MethodFunc> {
-    <T, O extends FetchOptions>(...params: Parameters<typeof fetch$1<T, O>>): ReturnType<typeof fetch$1<T, O>>;
+};
+interface FetchWithMethods extends FetchWithoutMethods {
+    get: FetchMethodFunc;
+    head: FetchMethodFunc;
+    options: FetchMethodFunc;
+    delete: PostMethodFunc;
+    patch: PostMethodFunc;
+    post: PostMethodFunc;
+    put: PostMethodFunc;
 }
-declare const fetch: DefaultFetch;
+/**
+ * @function fetch
+ *
+ * A `fetch()` replacement that simplifies data fetching with automatic JSON parsing, request timeouts, retries,
+ * and powerful interceptors. It also includes deferred and throttled request capabilities for complex asynchronous
+ * control flows.
+ *
+ * Will reject promise if response status code is not 2xx (200 <= status < 300).
+ *
+ * ## Method Specific Functions
+ *
+ * While `fetch()` provides access to all HTTP request methods by specifying it in options (eg: `{ method: 'get' }`),
+ * for ease of use you can also use the following:
+ *
+ * - `fetch.delete(...)`
+ * - `fetch.get(...)`
+ * - `fetch.head(...)`
+ * - `fetch.options(...)`
+ * - `fetch.patch(...)`
+ * - `fetch.post(...)`
+ * - `fetch.put(...)`
+ *
+ * **Deferred variants:** To debounce/throttle requests.
+ *
+ * - `fetch.delete.deferred(...)`
+ * - `fetch.get.deferred(...)`
+ * - `fetch.head.deferred(...)`
+ * - `fetch.options.deferred(...)`
+ * - `fetch.patch.deferred(...)`
+ * - `fetch.post.deferred(...)`
+ * - `fetch.put.deferred(...)`
+ *
+ * @template T The type of the value that the `fetch` resolves to.
+ * @template TReturn Return value type.
+ *
+ * If `T` is not specified defaults to the following based on the value of `options.as`:
+ * - FetchAs.arrayBuffer: `ArrayBuffer`
+ * - FetchAs.blob: `Blob`
+ * - FetchAs.bytes: `Uint8Array<ArrayBuffer>`
+ * - FetchAs.formData: `FormData`
+ * - FetchAs.json: `unknown`
+ * - FetchAs.text: `string`
+ * - FetchAs.response: `Response`
+ * @param url
+ * @param options (optional) all built-in `fetch()` options such as "method", "headers" and the additionals below.
+ *
+ * Options' default values (excluding `method` and `retryIf`) can be configured to be EFFECTIVE GLOBALLY.
+ *
+ * ```typescript
+ * fetch.defaults = {
+ *     as: FetchAs.json,
+ *     errMsgs: {
+ *        invalidUrl: 'Invalid URL',
+ *        parseFailed: 'Failed to parse response as',
+ *        reqTimedout: 'Request timed out',
+ *        requestFailed: 'Request failed with status code:',
+ *     },
+ *     headers: new Headers([['content-type', 'application/json']]),
+ *     interceptors: {
+ *     	   error: [],
+ *     	   request: [],
+ *     	   response: [],
+ *     	   result: [],
+ *     },
+ *     timeout: 0,
+ *     ........
+ * }
+ * ```
+ * @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.
+ * Default: {@link FetchAs.json}
+ * For raw `Response` use {@link FetchAs.response}
+ *
+ * @example Make a simple HTTP requests
+ * ```typescript
+ * import { fetch } from '@superutils/fetch'
+ *
+ * // no need for `response.json()` or `result.data.theActualData` drilling
+ * fetch('https://dummyjson.com/products/1').then(theActualData => console.log(theActualData))
+ * ```
+ */
+declare const fetch: FetchWithMethods;
 
-export { type Config, type DefaultFetch, type FetchArgs, type FetchArgsInterceptor, FetchAs, type FetchConf, type FetchDeferred, type FetchDeferredArgs, type FetchErrMsgs, FetchError, type FetchInterceptorError, type FetchInterceptorRequest, type FetchInterceptorResponse, type FetchInterceptorResult, type FetchInterceptors, type FetchOptions, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type Func, type Interceptor, type MethodFunc, type PostArgs, type PostBody, config, 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 FetchMethodFunc, type FetchOptions, type FetchOptionsDefaults, type FetchOptionsInterceptor, type FetchResult, type FetchRetryOptions, type FetchWithMethods, type FetchWithoutMethods, type Interceptor, type PostArgs, type PostBody, type PostDeferredCallbackArgs, type PostMethodFunc, type PostOptions, fetch as default, fetch, fetchDeferred, mergeFetchOptions, postDeferred };

package/dist/index.js

@@ -1,62 +1,6 @@
-// src/config.ts
-import {
-  config as promiseConfig
-} from "@superutils/promise";
-
-// src/types.ts
-var FetchAs = /* @__PURE__ */ ((FetchAs3) => {
-  FetchAs3["arrayBuffer"] = "arrayBuffer";
-  FetchAs3["blob"] = "blob";
-  FetchAs3["bytes"] = "bytes";
-  FetchAs3["formData"] = "formData";
-  FetchAs3["json"] = "json";
-  FetchAs3["response"] = "response";
-  FetchAs3["text"] = "text";
-  return FetchAs3;
-})(FetchAs || {});
-var FetchError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "FetchError";
-    this.options = options.options;
-    this.response = options.response;
-    this.url = options.url;
-  }
-};
-
-// src/config.ts
-var fetchOptions = {
-  as: "json" /* json */,
-  errMsgs: {
-    invalidUrl: "Invalid URL",
-    parseFailed: "Failed to parse response as",
-    reqTimedout: "Request timed out",
-    requestFailed: "Request failed with status code:"
-  },
-  // all error messages must be defined here
-  headers: new Headers([["content-type", "application/json"]]),
-  /** Global interceptors for fetch requests */
-  interceptors: {
-    /**
-     * Global error interceptors to be invoked whenever an exception occurs
-     * Returning an
-     */
-    error: [],
-    /** Interceptors to be invoked before making fetch requests */
-    request: [],
-    response: [],
-    result: []
-  },
-  ...promiseConfig.retryOptions,
-  retryIf: null,
-  timeout: 0
-};
-var config = promiseConfig;
-config.fetchOptions = fetchOptions;
-var config_default = config;
-
 // src/fetch.ts
 import {
+  isEmpty as isEmpty2,
   isFn as isFn2,
   isPositiveNumber,
   isPromise,
@@ -64,35 +8,6 @@ import {
 } from "@superutils/core";
 import PromisE2 from "@superutils/promise";
 
-// src/mergeFetchOptions.ts
-import { isEmpty, objKeys } from "@superutils/core";
-var mergeFetchOptions = (...allOptions) => allOptions.reduce((o1, o2) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
-  const { errMsgs = {}, headers, interceptors: ints1 = {} } = o1;
-  const { errMsgs: msgs2 = {}, interceptors: ints2 = {} } = o2;
-  o2.headers && new Headers(o2.headers).forEach(
-    (value, key) => headers.set(key, value)
-  );
-  for (const key of objKeys(msgs2)) {
-    if (!isEmpty(msgs2[key])) continue;
-    errMsgs[key] = msgs2[key];
-  }
-  return {
-    ...o1,
-    ...o2,
-    errMsgs,
-    headers,
-    interceptors: {
-      error: (_c = (_b = ints1 == null ? void 0 : ints1.error) == null ? void 0 : _b.concat((_a = ints2 == null ? void 0 : ints2.error) != null ? _a : [])) != null ? _c : [],
-      request: (_f = (_e = ints1 == null ? void 0 : ints1.request) == null ? void 0 : _e.concat((_d = ints2 == null ? void 0 : ints2.request) != null ? _d : [])) != null ? _f : [],
-      response: (_i = (_h = ints1 == null ? void 0 : ints1.response) == null ? void 0 : _h.concat((_g = ints2 == null ? void 0 : ints2.response) != null ? _g : [])) != null ? _i : [],
-      result: (_l = (_k = ints1 == null ? void 0 : ints1.result) == null ? void 0 : _k.concat((_j = ints2 == null ? void 0 : ints2.result) != null ? _j : [])) != null ? _l : []
-    },
-    timeout: (_n = (_m = o2.timeout) != null ? _m : o1.timeout) != null ? _n : 0
-  };
-}, config_default.fetchOptions);
-var mergeFetchOptions_default = mergeFetchOptions;
-
 // src/executeInterceptors.ts
 import { fallbackIfFails, isFn } from "@superutils/core";
 var executeInterceptors = async (value, interceptors, ...args) => {
@@ -110,40 +25,99 @@ var executeInterceptors_default = executeInterceptors;
 
 // src/getResponse.ts
 import PromisE from "@superutils/promise";
-var getResponse = async (...[url, options]) => {
-  const doFetch = () => globalThis.fetch(url, options).catch(
-    (err) => err.message === "Failed to fetch" ? (
-      // catch network errors to allow retries
-      new Response(null, {
-        status: 0,
-        statusText: "Network Error"
-      })
-    ) : globalThis.Promise.reject(err)
-  );
-  const response = await PromisE.retry(doFetch, {
+import { isPositiveInteger } from "@superutils/core";
+var getResponse = async (...[url, options = {}]) => {
+  let attemptCount = 0;
+  const doFetch = async () => {
+    attemptCount++;
+    return globalThis.fetch(url, options).catch(
+      (err) => err.message === "Failed to fetch" ? (
+        // catch network errors to allow retries
+        new Response(null, {
+          status: 0,
+          statusText: "Network Error"
+        })
+      ) : Promise.reject(err)
+    );
+  };
+  if (!isPositiveInteger(options.retry)) return doFetch();
+  const response = PromisE.retry(doFetch, {
     ...options,
-    retryIf: (res, count) => {
+    retryIf: async (res, count) => {
       var _a;
-      return !(res == null ? void 0 : res.ok) && ((_a = options == null ? void 0 : options.retryIf) == null ? void 0 : _a.call(options, res, count)) !== false;
+      return (res == null ? void 0 : res.ok) === false || await ((_a = options == null ? void 0 : options.retryIf) == null ? void 0 : _a.call(options, res, count)) === true;
     }
-  }).catch((err) => {
-    if (!(options == null ? void 0 : options.retry)) return Promise.reject(err);
-    const msg = `Request failed after attempt #${(options.retry || 0) + 1}`;
-    return Promise.reject(new Error(msg, { cause: err }));
-  });
+  }).catch(
+    (err) => Promise.reject(
+      new Error(`Request failed after attempt #${attemptCount}`, {
+        cause: err
+      })
+    )
+  );
   return response;
 };
 var getResponse_default = getResponse;
 
+// src/mergeFetchOptions.ts
+import { isEmpty, objKeys } from "@superutils/core";
+var mergeFetchOptions = (...allOptions) => allOptions.reduce(
+  (o1, o2) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    const { errMsgs = {}, headers, interceptors: ints1 = {} } = o1;
+    const { errMsgs: msgs2 = {}, interceptors: ints2 = {} } = o2;
+    o2.headers && new Headers(o2.headers).forEach((value, key) => {
+      headers && headers.set(key, value);
+    });
+    for (const key of objKeys(msgs2)) {
+      if (!isEmpty(msgs2[key])) errMsgs[key] = msgs2[key];
+    }
+    return {
+      ...o1,
+      ...o2,
+      errMsgs,
+      headers,
+      interceptors: {
+        error: (_c = (_b = ints1 == null ? void 0 : ints1.error) == null ? void 0 : _b.concat((_a = ints2 == null ? void 0 : ints2.error) != null ? _a : [])) != null ? _c : [],
+        request: (_f = (_e = ints1 == null ? void 0 : ints1.request) == null ? void 0 : _e.concat((_d = ints2 == null ? void 0 : ints2.request) != null ? _d : [])) != null ? _f : [],
+        response: (_i = (_h = ints1 == null ? void 0 : ints1.response) == null ? void 0 : _h.concat((_g = ints2 == null ? void 0 : ints2.response) != null ? _g : [])) != null ? _i : [],
+        result: (_l = (_k = ints1 == null ? void 0 : ints1.result) == null ? void 0 : _k.concat((_j = ints2 == null ? void 0 : ints2.result) != null ? _j : [])) != null ? _l : []
+      },
+      timeout: (_n = (_m = o2.timeout) != null ? _m : o1.timeout) != null ? _n : 0
+    };
+  },
+  { headers: new Headers() }
+);
+var mergeFetchOptions_default = mergeFetchOptions;
+
+// src/types.ts
+var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
+  FetchAs2["arrayBuffer"] = "arrayBuffer";
+  FetchAs2["blob"] = "blob";
+  FetchAs2["bytes"] = "bytes";
+  FetchAs2["formData"] = "formData";
+  FetchAs2["json"] = "json";
+  FetchAs2["response"] = "response";
+  FetchAs2["text"] = "text";
+  return FetchAs2;
+})(FetchAs || {});
+var FetchError = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "FetchError";
+    this.options = options.options;
+    this.response = options.response;
+    this.url = options.url;
+  }
+};
+
 // src/fetch.ts
-function fetch(url, options = {}) {
-  var _a;
+var fetch = (url, options = {}) => {
   let abortCtrl;
   let timeoutId;
-  (_a = options.method) != null ? _a : options.method = "get";
   const promise = new PromisE2(async (resolve, reject) => {
-    var _a2, _b;
-    const _options = mergeFetchOptions_default(options);
+    var _a, _b;
+    const _options = mergeFetchOptions_default(fetch.defaults, options);
+    if (isEmpty2(_options.method)) _options.method = "get";
     const errorInterceptors = [..._options.interceptors.error];
     const requestInterceptors = [..._options.interceptors.request];
     const responseInterceptors = [..._options.interceptors.response];
@@ -151,10 +125,10 @@ function fetch(url, options = {}) {
     url = await executeInterceptors_default(url, requestInterceptors, url, _options);
     const { as: parseAs, errMsgs, timeout } = _options;
     if (isPositiveNumber(timeout)) {
-      (_a2 = _options.abortCtrl) != null ? _a2 : _options.abortCtrl = new AbortController();
+      (_a = _options.abortCtrl) != null ? _a : _options.abortCtrl = new AbortController();
       timeoutId = setTimeout(() => {
-        var _a3;
-        return (_a3 = _options.abortCtrl) == null ? void 0 : _a3.abort();
+        var _a2;
+        return (_a2 = _options.abortCtrl) == null ? void 0 : _a2.abort();
       }, timeout);
     }
     abortCtrl = _options.abortCtrl;
@@ -183,12 +157,12 @@ function fetch(url, options = {}) {
       const parseFunc = response[parseAs];
       if (isFn2(parseFunc)) {
         const handleErr = (err) => {
-          var _a3, _b2;
+          var _a2, _b2;
           err = new Error(
             [
               errMsgs.parseFailed,
               parseAs + ".",
-              (_b2 = `${(_a3 = err == null ? void 0 : err.message) != null ? _a3 : err}`) == null ? void 0 : _b2.replace("Error: ", "")
+              (_b2 = `${(_a2 = err == null ? void 0 : err.message) != null ? _a2 : err}`) == null ? void 0 : _b2.replace("Error: ", "")
             ].join(" "),
             { cause: err }
           );
@@ -227,32 +201,53 @@ function fetch(url, options = {}) {
   });
   promise.onEarlyFinalize.push(() => abortCtrl == null ? void 0 : abortCtrl.abort());
   return promise;
-}
+};
+fetch.defaults = {
+  as: "json" /* json */,
+  errMsgs: {
+    invalidUrl: "Invalid URL",
+    parseFailed: "Failed to parse response as",
+    reqTimedout: "Request timed out",
+    requestFailed: "Request failed with status code:"
+  },
+  // all error messages must be defined here
+  headers: new Headers([["content-type", "application/json"]]),
+  /** Global interceptors for fetch requests */
+  interceptors: {
+    /**
+     * Global error interceptors to be invoked whenever an exception occurs
+     * Returning an
+     */
+    error: [],
+    /** Interceptors to be invoked before making fetch requests */
+    request: [],
+    response: [],
+    result: []
+  },
+  timeout: 0
+};
 var fetch_default = fetch;
 
 // src/fetchDeferred.ts
-import { forceCast } from "@superutils/core";
 import PromisE3 from "@superutils/promise";
 import {
   ResolveError,
   ResolveIgnored
 } from "@superutils/promise";
-function fetchDeferred(deferOptions = {}, defaultUrl, defaultOptions) {
+function fetchDeferred(deferOptions = {}, globalUrl, defaultOptions) {
   let _abortCtrl;
   const fetchCallback = (...args) => {
-    var _a, _b;
-    const [url, options = {}] = args;
-    (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
-    (_b = options.timeout) != null ? _b : options.timeout = defaultOptions == null ? void 0 : defaultOptions.timeout;
-    options.errMsgs = { ...defaultOptions == null ? void 0 : defaultOptions.errMsgs, ...options.errMsgs };
-    const { abortCtrl } = options;
-    _abortCtrl == null ? void 0 : _abortCtrl.abort();
-    _abortCtrl = abortCtrl;
+    var _a, _b, _c;
+    let options = {
+      ...(_a = globalUrl === 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(
-      ...forceCast([
-        url != null ? url : defaultUrl,
-        mergeFetchOptions_default(defaultOptions != null ? defaultOptions : {}, options)
-      ])
+      globalUrl != null ? globalUrl : args[0],
+      options
     );
     promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
     return promise;
@@ -262,7 +257,6 @@ function fetchDeferred(deferOptions = {}, defaultUrl, defaultOptions) {
 var fetchDeferred_default = fetchDeferred;
 
 // src/postDeferred.ts
-import { forceCast as forceCast2 } from "@superutils/core";
 import PromisE4 from "@superutils/promise";
 
 // src/post.ts
@@ -285,21 +279,22 @@ import {
   ResolveError as ResolveError2,
   ResolveIgnored as ResolveIgnored2
 } from "@superutils/promise";
-function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions) {
+function postDeferred(deferOptions = {}, globalUrl, globalData, defaultOptions) {
   let _abortCtrl;
-  const doPost = (...[url, data, options = {}]) => {
-    var _a;
-    (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
-    _abortCtrl == null ? void 0 : _abortCtrl.abort();
-    _abortCtrl = options.abortCtrl;
-    const mergedOptions = mergeFetchOptions_default(options, defaultOptions != null ? defaultOptions : {});
-    const promise = post(
-      ...forceCast2([
-        url != null ? url : defaultUrl,
-        data != null ? data : defaultData,
-        mergedOptions
-      ])
+  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];
+    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);
     promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
     return promise;
   };
@@ -308,37 +303,37 @@ function postDeferred(deferOptions = {}, defaultUrl, defaultData, defaultOptions
 var postDeferred_default = postDeferred;
 
 // src/index.ts
-var fetchGet = (method = "get") => {
-  const methodFunc = ((url, options = {}) => {
-    ;
-    options.method = method;
-    return fetch_default(url, options);
+import { isObj } from "@superutils/core";
+var createFetchMethodFunc = (method = "get") => {
+  const methodFunc = ((url, options) => {
+    const _options = isObj(options) ? options : {};
+    _options.method = method;
+    return fetch_default(url, _options);
   });
-  methodFunc.deferred = (...args) => fetchDeferred_default(...args);
+  methodFunc.deferred = ((...args) => fetchDeferred_default(...args));
   return methodFunc;
 };
-var fetchPost = (method = "post") => {
-  const methodFunc = ((url, options = {}) => {
-    ;
-    options.method = method;
-    return post(url, options);
+var createPostMethodFunc = (method = "post") => {
+  const methodFunc = ((url, data, options) => {
+    const _options = isObj(options) ? options : {};
+    _options.method = method;
+    return post(url, data, _options);
   });
-  methodFunc.deferred = (...args) => postDeferred_default(...args);
+  methodFunc.deferred = ((...args) => postDeferred_default(...args));
   return methodFunc;
 };
 var fetch2 = fetch_default;
-fetch2.get = fetchGet("get");
-fetch2.head = fetchGet("head");
-fetch2.delete = fetchGet("options");
-fetch2.delete = fetchPost("delete");
-fetch2.patch = fetchPost("patch");
-fetch2.post = fetchPost("post");
-fetch2.put = fetchPost("put");
+fetch2.get = createFetchMethodFunc("get");
+fetch2.head = createFetchMethodFunc("head");
+fetch2.options = createFetchMethodFunc("options");
+fetch2.delete = createPostMethodFunc("delete");
+fetch2.patch = createPostMethodFunc("patch");
+fetch2.post = createPostMethodFunc("post");
+fetch2.put = createPostMethodFunc("put");
 var index_default = fetch2;
 export {
   FetchAs,
   FetchError,
-  config,
   index_default as default,
   fetch2 as fetch,
   fetchDeferred,

package/package.json

@@ -1,9 +1,9 @@
 {
 	"author": "Toufiqur Rahaman Chowdhury",
-	"description": "Fetch utilities",
+	"description": "A lightweight `fetch` wrapper for browsers and Node.js, designed to simplify data fetching and reduce boilerplate.",
 	"dependencies": {
-		"@superutils/core": "^1.0.1",
-		"@superutils/promise": "^1.0.2"
+		"@superutils/core": "^1.0.5",
+		"@superutils/promise": "^1.0.6"
 	},
 	"files": [
 		"dist",
@@ -20,8 +20,8 @@
 	"main": "dist/index.js",
 	"name": "@superutils/fetch",
 	"peerDependencies": {
-		"@superutils/core": "^1.0.1",
-		"@superutils/promise": "^1.0.2"
+		"@superutils/core": "^1.0.5",
+		"@superutils/promise": "^1.0.6"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -31,10 +31,11 @@
 		"_watch": "tsc -p tsconfig.json --watch",
 		"build": "tsup src/index.ts --format esm --dts --clean --config ../../tsup.config.js",
 		"dev": "npm run build -- --watch",
-		"test": "cd ../../ && npm run test promise"
+		"start": "npm run build -- --watch",
+		"test": "cd ../../ && npm run test fetch"
 	},
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "0.1.0"
+	"version": "1.0.1"
 }