@superutils/fetch 1.2.2 → 1.3.0

package/dist/index.js

@@ -1,21 +1,24 @@
 // src/createClient.ts
-import PromisE3 from "@superutils/promise";
+import { deferredCallback } from "@superutils/promise";
 
 // src/fetch.ts
 import {
-  fallbackIfFails as fallbackIfFails2,
+  fallbackIfFails as fallbackIfFails3,
   isFn as isFn2,
   isPositiveNumber,
   isPromise,
   isUrlValid
 } from "@superutils/core";
-import PromisE2 from "@superutils/promise";
+import {
+  timeout as PromisE_timeout
+} from "@superutils/promise";
 
 // src/executeInterceptors.ts
 import { fallbackIfFails, isFn } from "@superutils/core";
-var executeInterceptors = async (value, interceptors = [], ...args) => {
+var executeInterceptors = async (value, signal, interceptors, ...args) => {
   var _a;
-  for (const interceptor of [...interceptors || []].filter(isFn)) {
+  for (const interceptor of [...interceptors != null ? interceptors : []].filter(isFn)) {
+    if (signal == null ? void 0 : signal.aborted) return value;
     value = (_a = await fallbackIfFails(
       interceptor,
       [value, ...args],
@@ -26,24 +29,48 @@ var executeInterceptors = async (value, interceptors = [], ...args) => {
 };
 var executeInterceptors_default = executeInterceptors;
 
+// src/getAbortCtrl.ts
+var getAbortCtrl = (options) => {
+  options != null ? options : options = {};
+  if (!(options.abortCtrl instanceof AbortController))
+    options.abortCtrl = new AbortController();
+  const { abortCtrl, signal } = options;
+  if (signal instanceof AbortSignal && !signal.aborted) {
+    const handleAbort = () => abortCtrl.abort();
+    signal.addEventListener("abort", handleAbort, { once: true });
+    abortCtrl.signal.addEventListener(
+      "abort",
+      () => signal.removeEventListener("abort", handleAbort),
+      { once: true }
+    );
+  }
+  return abortCtrl;
+};
+
 // src/getResponse.ts
-import PromisE from "@superutils/promise";
-import { isPositiveInteger } from "@superutils/core";
-var getResponse = async (...[url, options = {}]) => {
-  const fetchFunc = globalThis.fetch;
+import { fallbackIfFails as fallbackIfFails2, isPositiveInteger } from "@superutils/core";
+import { retry } from "@superutils/promise";
+var getResponse = async (url, options = {}) => {
+  const { abortCtrl, fetchFunc = globalThis.fetch } = options;
   if (!isPositiveInteger(options.retry))
     return fetchFunc(url, options);
   let attemptCount = 0;
-  const response = PromisE.retry(
+  const response = retry(
     () => {
       attemptCount++;
       return fetchFunc(url, options);
     },
     {
       ...options,
-      retryIf: async (res, count) => {
-        var _a;
-        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;
+      retryIf: async (res, count, error) => {
+        var _a, _b;
+        if (abortCtrl == null ? void 0 : abortCtrl.signal.aborted) return false;
+        const failed = !!error || !(res == null ? void 0 : res.ok);
+        return !!((_b = await fallbackIfFails2(
+          (_a = options == null ? void 0 : options.retryIf) != null ? _a : failed,
+          [res, count, error],
+          failed
+        )) != null ? _b : failed);
       }
     }
   ).catch(
@@ -58,21 +85,22 @@ var getResponse = async (...[url, options = {}]) => {
 var getResponse_default = getResponse;
 
 // src/mergeFetchOptions.ts
-import { isEmpty, objKeys } from "@superutils/core";
+import { isEmpty, isObj, objKeys } from "@superutils/core";
 var mergeFetchOptions = (...allOptions) => allOptions.reduce(
-  (o1, o2) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    const { errMsgs = {}, headers, interceptors: ints1 = {} } = o1;
-    const { errMsgs: msgs2 = {}, interceptors: ints2 = {} } = o2;
-    o2.headers && new Headers(o2.headers).forEach((value, key) => {
+  (merged, next) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    next = isObj(next) ? next : {};
+    const { errMsgs = {}, headers, interceptors: ints1 = {} } = merged;
+    const { errMsgs: msgs2 = {}, interceptors: ints2 = {} } = next;
+    next.headers && new Headers(next.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,
+      ...merged,
+      ...next,
       errMsgs,
       headers,
       interceptors: {
@@ -90,7 +118,7 @@ var mergeFetchOptions = (...allOptions) => allOptions.reduce(
           ...(_h = ints2 == null ? void 0 : ints2.result) != null ? _h : []
         ]
       },
-      timeout: (_j = (_i = o2.timeout) != null ? _i : o1.timeout) != null ? _j : 0
+      timeout: (_i = next.timeout) != null ? _i : merged.timeout
     };
   },
   { headers: new Headers() }
@@ -101,11 +129,22 @@ var mergePartialOptions = (...optionsAr) => {
   return optionsAr.length <= 1 ? optionsAr[0] : mergeFetchOptions(...optionsAr);
 };
 
-// src/types.ts
-import {
-  ResolveError,
-  ResolveIgnored
-} from "@superutils/promise";
+// src/types/constants.ts
+var ContentType = {
+  APPLICATION_JAVASCRIPT: "application/javascript",
+  APPLICATION_JSON: "application/json",
+  APPLICATION_OCTET_STREAM: "application/octet-stream",
+  APPLICATION_PDF: "application/pdf",
+  APPLICATION_X_WWW_FORM_URLENCODED: "application/x-www-form-urlencoded",
+  APPLICATION_XML: "application/xml",
+  APPLICATION_ZIP: "application/zip",
+  AUDIO_MPEG: "audio/mpeg",
+  MULTIPART_FORM_DATA: "multipart/form-data",
+  TEXT_CSS: "text/css",
+  TEXT_HTML: "text/html",
+  TEXT_PLAIN: "text/plain",
+  VIDEO_MP4: "video/mp4"
+};
 var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
   FetchAs2["arrayBuffer"] = "arrayBuffer";
   FetchAs2["blob"] = "blob";
@@ -116,161 +155,195 @@ var FetchAs = /* @__PURE__ */ ((FetchAs2) => {
   FetchAs2["text"] = "text";
   return FetchAs2;
 })(FetchAs || {});
+
+// src/types/FetchError.ts
 var FetchError = class _FetchError extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
-    this.clone = (newMessage) => new _FetchError(newMessage, {
-      cause: this.cause,
-      options: this.options,
-      response: this.response,
-      url: this.url
-    });
     this.name = "FetchError";
-    this.options = options.options;
-    this.response = options.response;
-    this.url = options.url;
+    Object.defineProperties(this, {
+      clone: {
+        get() {
+          return (newMessage) => new _FetchError(newMessage, {
+            cause: options.cause,
+            options: options.options,
+            response: options.response,
+            url: options.url
+          });
+        }
+      },
+      options: {
+        get() {
+          return options.options;
+        }
+      },
+      response: {
+        get() {
+          return options.response;
+        }
+      },
+      url: {
+        get() {
+          return options.url;
+        }
+      }
+    });
   }
 };
 
+// src/types/options.ts
+import {
+  ResolveError,
+  ResolveIgnored
+} from "@superutils/promise";
+
 // src/fetch.ts
+var MAX_TIMEOUT = 2147483647;
 var fetch = (url, options = {}) => {
-  let abortCtrl;
-  let timeoutId;
-  const promise = new PromisE2(async (resolve, reject) => {
-    var _a, _b, _c;
-    let errResponse;
-    const _options2 = mergeFetchOptions_default(fetch.defaults, options);
-    (_a = _options2.as) != null ? _a : _options2.as = "json" /* json */;
-    (_b = _options2.method) != null ? _b : _options2.method = "get";
-    _options2.abortCtrl = _options2.abortCtrl instanceof AbortController ? _options2.abortCtrl : new AbortController();
-    url = await executeInterceptors_default(
+  var _a, _b, _c;
+  let errResponse;
+  const _options = mergeFetchOptions_default(fetch.defaults, options);
+  _options.abortCtrl = getAbortCtrl(_options);
+  (_a = _options.as) != null ? _a : _options.as = "json" /* json */;
+  (_b = _options.method) != null ? _b : _options.method = "get";
+  (_c = _options.signal) != null ? _c : _options.signal = _options.abortCtrl.signal;
+  _options.timeout = Math.min(
+    isPositiveNumber(_options.timeout) ? _options.timeout : fetch.defaults.timeout,
+    MAX_TIMEOUT
+  );
+  const { abortCtrl, as: parseAs, headers, timeout } = _options;
+  let contentType = headers.get("content-type");
+  if (!contentType) {
+    headers.set("content-type", ContentType.APPLICATION_JSON);
+    contentType = ContentType.APPLICATION_JSON;
+  }
+  const processErr = (err) => {
+    var _a2, _b2, _c2, _d, _e;
+    let msg = (_a2 = err == null ? void 0 : err.message) != null ? _a2 : err;
+    if ((err == null ? void 0 : err.name) === "AbortError") msg = (_c2 = (_b2 = _options.errMsgs) == null ? void 0 : _b2.aborted) != null ? _c2 : msg;
+    return executeInterceptors_default(
+      new FetchError(msg, {
+        cause: (_d = err == null ? void 0 : err.cause) != null ? _d : err,
+        response: errResponse,
+        options: _options,
+        url
+      }),
+      void 0,
+      // should execute regardless of abort status
+      (_e = _options.interceptors) == null ? void 0 : _e.error,
       url,
-      _options2.interceptors.request,
-      _options2
-    );
-    const {
-      as: parseAs,
-      body,
-      errMsgs,
-      timeout,
-      validateUrl = true
-    } = _options2;
-    if (isPositiveNumber(timeout)) {
-      timeoutId = setTimeout(() => {
-        var _a2;
-        return (_a2 = _options2.abortCtrl) == null ? void 0 : _a2.abort();
-      }, timeout);
-    }
-    abortCtrl = _options2.abortCtrl;
-    if (_options2.abortCtrl) _options2.signal = _options2.abortCtrl.signal;
+      _options
+    ).then((err2) => Promise.reject(err2));
+  };
+  const start = async () => {
+    var _a2, _b2, _c2, _d;
     try {
+      url = await executeInterceptors_default(
+        url,
+        abortCtrl.signal,
+        (_a2 = _options.interceptors) == null ? void 0 : _a2.request,
+        _options
+      );
+      const { body, errMsgs, validateUrl = true } = _options;
+      (_b2 = _options.signal) != null ? _b2 : _options.signal = abortCtrl.signal;
       if (validateUrl && !isUrlValid(url, false))
-        throw new Error(errMsgs.invalidUrl);
-      if (!["undefined", "string"].includes(typeof body))
-        _options2.body = JSON.stringify(
-          isFn2(body) ? fallbackIfFails2(body, [], void 0) : body
+        return processErr(new Error(errMsgs.invalidUrl));
+      const shouldStringifyBody = [
+        ContentType.APPLICATION_JSON,
+        ContentType.APPLICATION_X_WWW_FORM_URLENCODED
+      ].find((x) => contentType.includes(x)) && !["undefined", "string"].includes(typeof body);
+      if (shouldStringifyBody)
+        _options.body = JSON.stringify(
+          isFn2(body) ? fallbackIfFails3(body, [], void 0) : body
         );
-      let response = await getResponse_default(url, _options2);
+      let response = await getResponse_default(url, _options);
       response = await executeInterceptors_default(
         response,
-        _options2.interceptors.response,
+        abortCtrl.signal,
+        (_c2 = _options.interceptors) == null ? void 0 : _c2.response,
         url,
-        _options2
+        _options
       );
       errResponse = response;
       const { status = 0 } = response;
       const isSuccess = status >= 200 && status < 300;
       if (!isSuccess) {
-        const fallbackMsg = `${errMsgs.requestFailed} ${status}`;
-        const jsonError = await fallbackIfFails2(
+        const jsonError = await fallbackIfFails3(
           // try to parse error response as json first
           () => response.json(),
           [],
           void 0
         );
-        const message = (jsonError == null ? void 0 : jsonError.message) || fallbackMsg;
-        throw new Error(`${message}`.replace("Error: ", ""), {
-          cause: jsonError
-        });
+        throw new Error(
+          (jsonError == null ? void 0 : jsonError.message) || `${errMsgs.requestFailed} ${status}`,
+          { cause: jsonError }
+        );
       }
-      let result = response;
       const parseFunc = response[parseAs];
-      if (isFn2(parseFunc)) {
-        const handleErr = (err) => {
-          err = new Error(
-            `${errMsgs.parseFailed} ${parseAs}. ${err == null ? void 0 : err.message}`,
-            { cause: err }
-          );
-          return Promise.reject(err);
-        };
-        result = parseFunc.bind(response)();
-        if (isPromise(result)) result = result.catch(handleErr);
-      }
+      let result = !isFn2(parseFunc) ? response : parseFunc.bind(response)();
+      if (isPromise(result))
+        result = await result.catch(
+          (err) => Promise.reject(
+            new Error(
+              `${errMsgs.parseFailed} ${parseAs}. ${err == null ? void 0 : err.message}`,
+              { cause: err }
+            )
+          )
+        );
       result = await executeInterceptors_default(
         result,
-        _options2.interceptors.result,
-        url,
-        _options2
-      );
-      resolve(result);
-    } catch (err) {
-      const errX = err;
-      const msg = (errX == null ? void 0 : errX.name) === "AbortError" ? errMsgs.reqTimedout : err == null ? void 0 : err.message;
-      let error = new FetchError(msg, {
-        cause: (_c = errX == null ? void 0 : errX.cause) != null ? _c : err,
-        response: errResponse,
-        options: _options2,
-        url
-      });
-      error = await executeInterceptors_default(
-        error,
-        _options2.interceptors.error,
+        abortCtrl.signal,
+        (_d = _options.interceptors) == null ? void 0 : _d.result,
         url,
-        _options2
+        _options
       );
-      reject(error);
+      return result;
+    } catch (_err) {
+      return processErr(_err);
     }
-    timeoutId && clearTimeout(timeoutId);
-  });
-  promise.onEarlyFinalize.push(() => abortCtrl == null ? void 0 : abortCtrl.abort());
-  return promise;
+  };
+  return PromisE_timeout(
+    {
+      ...options,
+      abortCtrl,
+      onAbort: () => processErr(new Error(_options.errMsgs.aborted)),
+      onTimeout: async () => processErr(new Error(_options.errMsgs.timedout)),
+      signal: _options.signal,
+      timeout
+    },
+    start
+  );
 };
 fetch.defaults = {
   errMsgs: {
+    aborted: "Request aborted",
     invalidUrl: "Invalid URL",
     parseFailed: "Failed to parse response as",
-    reqTimedout: "Request timed out",
+    timedout: "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 */
+  headers: new Headers(),
   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: []
   },
-  /** Request timeout duration in milliseconds. Default: `0` */
-  timeout: 0,
+  timeout: 3e4,
   validateUrl: true
 };
 var fetch_default = fetch;
 
 // src/createClient.ts
-var createClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
+var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
   const func = (url, options) => {
     return fetch_default(
       url,
       mergePartialOptions(
         commonOptions,
         options,
-        mandatoryOptions
+        fixedOptions
       )
     );
   };
@@ -282,11 +355,10 @@ var createClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
         commonOptions,
         defaultOptions,
         defaultUrl === void 0 ? args[1] : args[0],
-        mandatoryOptions
+        fixedOptions
       );
-      (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
-      (_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl);
-      _abortCtrl = options.abortCtrl;
+      ((_a = _abortCtrl == null ? void 0 : _abortCtrl.signal) == null ? void 0 : _a.aborted) === false && ((_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl));
+      _abortCtrl = getAbortCtrl(options);
       const promise = fetch_default(
         defaultUrl != null ? defaultUrl : args[0],
         options
@@ -294,7 +366,7 @@ var createClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
       promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
       return promise;
     };
-    return PromisE3.deferredCallback(fetchCb, {
+    return deferredCallback(fetchCb, {
       ...commonDeferOptions,
       ...deferOptions
     });
@@ -304,20 +376,20 @@ var createClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
 var createClient_default = createClient;
 
 // src/createPostClient.ts
-import PromisE4 from "@superutils/promise";
-var createPostClient = (mandatoryOptions, commonOptions, commonDeferOptions) => {
-  const func = (url, data, options) => {
+import { deferredCallback as deferredCallback2 } from "@superutils/promise";
+var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
+  const client = (url, data, options) => {
     var _a;
-    const _options2 = mergePartialOptions(
+    const _options = mergePartialOptions(
       commonOptions,
       options,
-      mandatoryOptions
+      fixedOptions
     );
-    _options2.body = data;
-    (_a = _options2.method) != null ? _a : _options2.method = "post";
-    return fetch_default(url, _options2);
+    _options.body = data;
+    (_a = _options.method) != null ? _a : _options.method = "post";
+    return fetch_default(url, _options);
   };
-  func.deferred = (deferOptions = {}, defaultUrl, defaultData, defaultOptions) => {
+  client.deferred = (deferOptions = {}, defaultUrl, defaultData, defaultOptions) => {
     let _abortCtrl;
     const postCb = (...args) => {
       var _a, _b, _c, _d;
@@ -327,45 +399,34 @@ var createPostClient = (mandatoryOptions, commonOptions, commonDeferOptions) =>
         commonOptions,
         defaultOptions,
         args[2],
-        mandatoryOptions
+        fixedOptions
       );
-      (_a = options.abortCtrl) != null ? _a : options.abortCtrl = new AbortController();
-      (_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl);
-      _abortCtrl = options.abortCtrl;
+      ((_a = _abortCtrl == null ? void 0 : _abortCtrl.signal) == null ? void 0 : _a.aborted) === false && ((_b = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _b.call(_abortCtrl));
+      _abortCtrl = getAbortCtrl(options);
       options.body = (_c = args[1]) != null ? _c : options.body;
       (_d = options.method) != null ? _d : options.method = "post";
       const promise = fetch_default(args[0], options);
       promise.onEarlyFinalize.push(() => _abortCtrl == null ? void 0 : _abortCtrl.abort());
       return promise;
     };
-    return PromisE4.deferredCallback(postCb, {
+    return deferredCallback2(postCb, {
       ...commonDeferOptions,
       ...deferOptions
     });
   };
-  return func;
+  return client;
 };
 var createPostClient_default = createPostClient;
 
 // src/fetchResponse.ts
-var fetchResponse = (...args) => {
-  var _a, _b, _c;
-  (_a = args[1]) != null ? _a : args[1] = {};
-  (_c = (_b = args[1]).as) != null ? _c : _b.as = "response" /* response */;
-  return fetch_default(...args);
+var fetchResponse = (url, options) => {
+  var _a;
+  options != null ? options : options = {};
+  (_a = options.as) != null ? _a : options.as = "response" /* response */;
+  return fetch_default(url, options);
 };
-var fetchResponse_default = fetchResponse;
-
-// src/fetchDefault.ts
-var _get = createClient_default({ method: "get" });
-var _head = createClient_default({ method: "head" });
-var _options = createClient_default({ method: "options" });
-var _delete = createPostClient_default({ method: "delete" });
-var _patch = createPostClient_default({ method: "patch" });
-var _post = createPostClient_default({ method: "post" });
-var _put = createPostClient_default({ method: "put" });
-var fetchDefault = fetchResponse_default;
-Object.defineProperty(fetchDefault, "defaults", {
+fetchResponse.defaults = fetch_default.defaults;
+Object.defineProperty(fetchResponse, "defaults", {
   get() {
     return fetch_default.defaults;
   },
@@ -373,27 +434,52 @@ Object.defineProperty(fetchDefault, "defaults", {
     fetch_default.defaults = newDefaults;
   }
 });
-fetchDefault.delete = _delete;
-fetchDefault.get = _get;
-fetchDefault.head = _head;
-fetchDefault.options = _options;
-fetchDefault.patch = _patch;
-fetchDefault.post = _post;
-fetchDefault.put = _put;
-var fetchDefault_default = fetchDefault;
+var fetchResponse_default = fetchResponse;
+
+// src/defaultFetch.ts
+var methods = {
+  /** Make HTTP requests with method GET */
+  get: createClient_default({ method: "get" }),
+  /** Make HTTP requests with method HEAD */
+  head: createClient_default({ method: "head" }),
+  /** Make HTTP requests with method OPTIONS */
+  options: createClient_default({ method: "options" }),
+  /** Make HTTP requests with method DELETE */
+  delete: createPostClient_default({ method: "delete" }),
+  /** Make HTTP requests with method PATCH */
+  patch: createPostClient_default({ method: "patch" }),
+  /** Make HTTP requests with method POST */
+  post: createPostClient_default({ method: "post" }),
+  /** Make HTTP requests with method PUT */
+  put: createPostClient_default({ method: "put" })
+};
+var defaultFetch = fetchResponse_default;
+defaultFetch.delete = methods.delete;
+defaultFetch.get = methods.get;
+defaultFetch.head = methods.head;
+defaultFetch.options = methods.options;
+defaultFetch.patch = methods.patch;
+defaultFetch.post = methods.post;
+defaultFetch.put = methods.put;
+var defaultFetch_default = defaultFetch;
 
 // src/index.ts
-var index_default = fetchDefault_default;
+var index_default = defaultFetch_default;
 export {
+  ContentType,
   FetchAs,
   FetchError,
+  MAX_TIMEOUT,
   ResolveError,
   ResolveIgnored,
   createClient,
   createPostClient,
   index_default as default,
+  executeInterceptors,
   fetch,
   fetchResponse,
+  getAbortCtrl,
+  getResponse,
   mergeFetchOptions,
   mergePartialOptions
 };

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.1.5",
-		"@superutils/promise": "^1.1.5"
+		"@superutils/core": "^1.1.8",
+		"@superutils/promise": "^1.2.0"
 	},
 	"files": [
 		"dist",
@@ -24,8 +24,8 @@
 	"main": "dist/index.js",
 	"name": "@superutils/fetch",
 	"peerDependencies": {
-		"@superutils/core": "^1.1.5",
-		"@superutils/promise": "^1.1.5"
+		"@superutils/core": "^1.2.0",
+		"@superutils/promise": "^1.1.7"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -45,5 +45,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.2.2"
+	"version": "1.3.0"
 }