@superutils/fetch 1.4.2 → 1.5.1

package/dist/index.cjs

@@ -0,0 +1,477 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ContentType: () => ContentType,
+  FetchAs: () => FetchAs,
+  FetchError: () => FetchError,
+  ResolveError: () => import_promise2.ResolveError,
+  ResolveIgnored: () => import_promise2.ResolveIgnored,
+  TIMEOUT_FALLBACK: () => import_promise2.TIMEOUT_FALLBACK,
+  TIMEOUT_MAX: () => import_promise2.TIMEOUT_MAX,
+  TimeoutPromise: () => import_promise2.TimeoutPromise,
+  createClient: () => createClient,
+  createPostClient: () => createPostClient,
+  default: () => index_default,
+  executeInterceptors: () => executeInterceptors,
+  fetch: () => fetch2,
+  mergeOptions: () => mergeOptions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createClient.ts
+var import_promise4 = require("@superutils/promise");
+
+// src/fetch.ts
+var import_core4 = require("@superutils/core");
+var import_promise3 = require("@superutils/promise");
+
+// src/executeInterceptors.ts
+var import_core = require("@superutils/core");
+var executeInterceptors = async (value, signal, interceptors, ...args) => {
+  var _a;
+  for (const interceptor of [...interceptors != null ? interceptors : []].filter(import_core.isFn)) {
+    if (signal == null ? void 0 : signal.aborted) break;
+    value = (_a = await (0, import_core.fallbackIfFails)(
+      interceptor,
+      [value, ...args],
+      void 0
+    )) != null ? _a : value;
+  }
+  return value;
+};
+var executeInterceptors_default = executeInterceptors;
+
+// src/getResponse.ts
+var import_core2 = require("@superutils/core");
+var import_promise = require("@superutils/promise");
+var getResponse = (url, options = {}) => {
+  const fetchFunc = (0, import_core2.isFn)(options.fetchFunc) ? options.fetchFunc : globalThis.fetch;
+  if (!(0, import_core2.isPositiveInteger)(options.retry)) return fetchFunc(url, options);
+  let attemptCount = 0;
+  const response = (0, import_promise.retry)(
+    () => {
+      attemptCount++;
+      return fetchFunc(url, options);
+    },
+    {
+      ...options,
+      retryIf: async (res, count, error) => {
+        var _a;
+        const { abortCtrl, retryIf, signal } = options;
+        if ((abortCtrl == null ? void 0 : abortCtrl.signal.aborted) || (signal == null ? void 0 : signal.aborted)) return false;
+        return !!((_a = await (0, import_core2.fallbackIfFails)(
+          retryIf,
+          [res, count, error],
+          void 0
+        )) != null ? _a : !!error || !(res == null ? void 0 : res.ok));
+      }
+    }
+  ).catch(
+    (err) => Promise.reject(
+      new Error(`Request failed after attempt #${attemptCount}`, {
+        cause: err
+      })
+    )
+  );
+  return response;
+};
+var getResponse_default = getResponse;
+
+// src/mergeOptions.ts
+var import_core3 = require("@superutils/core");
+var mergeOptions = (...allOptions) => allOptions.reduce(
+  (merged, options) => {
+    var _a;
+    options = (0, import_core3.isObj)(options) ? options : {};
+    const { headers, interceptors: ints1 = {} } = merged;
+    const { interceptors: ints2 = {} } = options;
+    options.headers && new Headers(options.headers).forEach(
+      (value, key) => headers.set(key, value)
+    );
+    return {
+      ...merged,
+      ...options,
+      errMsgs: (0, import_core3.objCopy)(
+        options.errMsgs,
+        merged.errMsgs,
+        [],
+        "empty"
+      ),
+      headers,
+      interceptors: {
+        error: [...toArr(ints1 == null ? void 0 : ints1.error), ...toArr(ints2 == null ? void 0 : ints2.error)],
+        request: [
+          ...toArr(ints1 == null ? void 0 : ints1.request),
+          ...toArr(ints2 == null ? void 0 : ints2.request)
+        ],
+        response: [
+          ...toArr(ints1 == null ? void 0 : ints1.response),
+          ...toArr(ints2 == null ? void 0 : ints2.response)
+        ],
+        result: [...toArr(ints1 == null ? void 0 : ints1.result), ...toArr(ints2 == null ? void 0 : ints2.result)]
+      },
+      timeout: (_a = options.timeout) != null ? _a : merged.timeout
+    };
+  },
+  { headers: new Headers() }
+);
+var mergeOptions_default = mergeOptions;
+var toArr = (x) => (0, import_core3.isArr)(x) ? x : (0, import_core3.isFn)(x) ? [x] : [];
+
+// 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";
+  FetchAs2["bytes"] = "bytes";
+  FetchAs2["formData"] = "formData";
+  FetchAs2["json"] = "json";
+  FetchAs2["response"] = "response";
+  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.name = "FetchError";
+    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/index.ts
+var import_promise2 = require("@superutils/promise");
+
+// src/fetch.ts
+var fetch = (url, options = {}) => {
+  var _a, _b, _c;
+  let response;
+  const opts = mergeOptions_default(fetch.defaults, options);
+  opts.abortCtrl = opts.abortCtrl instanceof AbortController ? opts.abortCtrl : new AbortController();
+  (_a = opts.as) != null ? _a : opts.as = "response" /* response */;
+  (_b = opts.method) != null ? _b : opts.method = "get";
+  (_c = opts.signal) != null ? _c : opts.signal = opts.abortCtrl.signal;
+  const { abortCtrl, as: parseAs, headers, onAbort, onTimeout } = opts;
+  opts.onAbort = async () => {
+    var _a2, _b2, _c2, _d, _e, _f;
+    const err = (_f = (_e = (_c2 = await (0, import_core4.fallbackIfFails)(onAbort, [], void 0)) != null ? _c2 : (_b2 = (_a2 = opts.abortCtrl) == null ? void 0 : _a2.signal) == null ? void 0 : _b2.reason) != null ? _e : (_d = opts.signal) == null ? void 0 : _d.reason) != null ? _f : opts.errMsgs.aborted;
+    if ((0, import_core4.isError)(err) && err.name === "AbortError") {
+      err.message = ["This operation was aborted"].includes(err.message) ? opts.errMsgs.aborted : err.message;
+    }
+    return await interceptErr(
+      (0, import_core4.isError)(err) ? err : new Error(err),
+      url,
+      opts,
+      response
+    );
+  };
+  opts.onTimeout = async () => {
+    const err = await (0, import_core4.fallbackIfFails)(onTimeout, [], void 0);
+    return await interceptErr(
+      err != null ? err : new Error(opts.errMsgs.timedout),
+      url,
+      opts,
+      response
+    );
+  };
+  return (0, import_promise3.timeout)(opts, async () => {
+    var _a2, _b2, _c2, _d, _e;
+    try {
+      let contentType = headers.get("content-type");
+      if (!contentType) {
+        headers.set("content-type", ContentType.APPLICATION_JSON);
+        contentType = ContentType.APPLICATION_JSON;
+      }
+      url = await executeInterceptors_default(
+        url,
+        abortCtrl.signal,
+        (_a2 = opts.interceptors) == null ? void 0 : _a2.request,
+        opts
+      );
+      const { body, errMsgs, validateUrl = true } = opts;
+      (_b2 = opts.signal) != null ? _b2 : opts.signal = abortCtrl.signal;
+      if (validateUrl && !(0, import_core4.isUrlValid)(url, false))
+        throw new Error(errMsgs.invalidUrl);
+      const shouldStringifyBody = [
+        ContentType.APPLICATION_JSON,
+        ContentType.APPLICATION_X_WWW_FORM_URLENCODED
+      ].find((x) => contentType.includes(x)) && !["undefined", "string"].includes(typeof body);
+      if (shouldStringifyBody)
+        opts.body = JSON.stringify(
+          (0, import_core4.isFn)(body) ? (0, import_core4.fallbackIfFails)(body, [], void 0) : body
+        );
+      response = await getResponse_default(url, opts);
+      response = await executeInterceptors_default(
+        response,
+        abortCtrl.signal,
+        (_c2 = opts.interceptors) == null ? void 0 : _c2.response,
+        url,
+        opts
+      );
+      const status = (_d = response == null ? void 0 : response.status) != null ? _d : 0;
+      const isSuccess = status >= 200 && status < 300;
+      if (!isSuccess) {
+        const jsonError = await (0, import_core4.fallbackIfFails)(
+          // try to parse error response as json first
+          () => response.json(),
+          [],
+          void 0
+        );
+        throw new Error(
+          (jsonError == null ? void 0 : jsonError.message) || `${errMsgs.requestFailed} ${status}`,
+          { cause: jsonError }
+        );
+      }
+      const parseFunc = response[parseAs];
+      let result = !(0, import_core4.isFn)(parseFunc) ? response : parseFunc.bind(response)();
+      if ((0, import_core4.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,
+        abortCtrl.signal,
+        (_e = opts.interceptors) == null ? void 0 : _e.result,
+        url,
+        opts
+      );
+      return result;
+    } catch (_err) {
+      let err = _err;
+      err = await interceptErr(_err, url, opts, response);
+      return Promise.reject(err);
+    }
+  });
+};
+fetch.defaults = {
+  abortOnEarlyFinalize: true,
+  errMsgs: {
+    aborted: "Request aborted",
+    invalidUrl: "Invalid URL",
+    parseFailed: "Failed to parse response as",
+    timedout: "Request timed out",
+    requestFailed: "Request failed with status code:"
+  },
+  // all error messages must be defined here
+  headers: new Headers(),
+  interceptors: {
+    error: [],
+    request: [],
+    response: [],
+    result: []
+  },
+  timeout: 3e4,
+  validateUrl: true
+};
+var interceptErr = async (err, url, options, response) => {
+  var _a, _b, _c;
+  const fErr = await executeInterceptors_default(
+    new FetchError((_a = err == null ? void 0 : err.message) != null ? _a : err, {
+      cause: (_b = err == null ? void 0 : err.cause) != null ? _b : err,
+      response,
+      options,
+      url
+    }),
+    void 0,
+    // should execute regardless of abort status
+    (_c = options.interceptors) == null ? void 0 : _c.error,
+    url,
+    options
+  );
+  return fErr;
+};
+var fetch_default = fetch;
+
+// src/createClient.ts
+var createClient = (fixedOptions, commonOptions, commonDeferOptions) => {
+  function client(url, options) {
+    var _a;
+    const mergedOptions = mergeOptions_default(
+      commonOptions,
+      options,
+      fixedOptions
+      // fixed options will always override other options
+    );
+    (_a = mergedOptions.as) != null ? _a : mergedOptions.as = "json" /* json */;
+    return fetch_default(url, mergedOptions);
+  }
+  client.deferred = (deferOptions, defaultUrl, defaultOptions) => {
+    let _abortCtrl;
+    const fetchCb = (...args) => {
+      var _a, _b, _c;
+      const mergedOptions = (_a = mergeOptions_default(
+        commonOptions,
+        defaultOptions,
+        defaultUrl === void 0 ? args[1] : args[0],
+        fixedOptions
+        // fixed options will always override other options
+      )) != null ? _a : {};
+      (_b = mergedOptions.as) != null ? _b : mergedOptions.as = "json" /* json */;
+      (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
+      _abortCtrl = new AbortController();
+      return fetch_default(
+        defaultUrl != null ? defaultUrl : args[0],
+        mergedOptions
+      );
+    };
+    return (0, import_promise4.deferredCallback)(fetchCb, {
+      ...commonDeferOptions,
+      ...deferOptions
+    });
+  };
+  return client;
+};
+var createClient_default = createClient;
+
+// src/createPostClient.ts
+var import_promise5 = require("@superutils/promise");
+var createPostClient = (fixedOptions, commonOptions, commonDeferOptions) => {
+  function client(url, data, options) {
+    var _a, _b;
+    const mergedOptions = mergeOptions_default(
+      commonOptions,
+      options,
+      fixedOptions
+      // fixed options will always override other options
+    );
+    (_a = mergedOptions.as) != null ? _a : mergedOptions.as = "json" /* json */;
+    mergedOptions.body = data;
+    (_b = mergedOptions.method) != null ? _b : mergedOptions.method = "post";
+    return fetch_default(url, mergedOptions);
+  }
+  client.deferred = (deferOptions, defaultUrl, defaultData, defaultOptions) => {
+    let _abortCtrl;
+    const postCb = (...args) => {
+      var _a, _b, _c, _d, _e;
+      if (defaultUrl !== void 0) args.splice(0, 0, defaultUrl);
+      if (defaultData !== void 0) args.splice(1, 0, defaultData);
+      const mergedOptions = (_a = mergeOptions_default(
+        commonOptions,
+        defaultOptions,
+        args[2],
+        fixedOptions
+        // fixed options will always override other options
+      )) != null ? _a : {};
+      (_b = mergedOptions.as) != null ? _b : mergedOptions.as = "json" /* json */;
+      (_c = _abortCtrl == null ? void 0 : _abortCtrl.abort) == null ? void 0 : _c.call(_abortCtrl);
+      _abortCtrl = new AbortController();
+      mergedOptions.body = (_d = args[1]) != null ? _d : mergedOptions.body;
+      (_e = mergedOptions.method) != null ? _e : mergedOptions.method = "post";
+      return fetch_default(args[0], mergedOptions);
+    };
+    return (0, import_promise5.deferredCallback)(postCb, {
+      ...commonDeferOptions,
+      ...deferOptions
+    });
+  };
+  return client;
+};
+var createPostClient_default = createPostClient;
+
+// src/index.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 fetch2 = fetch_default;
+fetch2.delete = methods.delete;
+fetch2.get = methods.get;
+fetch2.head = methods.head;
+fetch2.options = methods.options;
+fetch2.patch = methods.patch;
+fetch2.post = methods.post;
+fetch2.put = methods.put;
+var index_default = fetch2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentType,
+  FetchAs,
+  FetchError,
+  ResolveError,
+  ResolveIgnored,
+  TIMEOUT_FALLBACK,
+  TIMEOUT_MAX,
+  TimeoutPromise,
+  createClient,
+  createPostClient,
+  executeInterceptors,
+  fetch,
+  mergeOptions
+});