vigor-fetch 1.0.4 → 1.0.6

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [2024] [Uav1010 / Your Full Name]
+Copyright (c) [2024] [Uav1010]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -12,7 +12,7 @@
 - 🎯 **Immutable Chaining**: Every configuration method returns a new instance, making it perfect for base templates and functional patterns.
 
 ## 📦 Installation
-```terminal
+```powershell
 
 npm install vigor-fetch
 

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-interface VigorErrorOptions {
+export interface VigorErrorOptions {
     url?: string | null;
     status?: number;
     message?: string;
     data?: any;
 }
-interface VigorFetchConfig {
+export interface VigorFetchConfig {
     path: string;
     method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | null;
     offset: RequestInit;
@@ -53,7 +53,7 @@ declare class VigorFetch<T = any> {
     onError(...arg: VigorFetchConfig['onError']): VigorFetch<T>;
     request(): Promise<T>;
 }
-interface VigorAllConfig {
+export interface VigorAllConfig {
     limit: number;
     jitter: number;
     promises: Array<() => Promise<any>>;
@@ -71,5 +71,4 @@ declare class Vigor {
     fetch<T = any>(origin: string, config?: VigorFetchConfig): VigorFetch<T>;
     all(config?: VigorAllConfig): VigorAll;
 }
-
-export { type VigorAllConfig, type VigorErrorOptions, type VigorFetchConfig, Vigor as default };
+export default Vigor;

package/dist/index.js

@@ -1,282 +1,194 @@
-"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);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
-var VigorError = class extends Error {
-  constructor(text, { url = null, status = 0, message, data = null }) {
-    super(text);
-    this.name = "VigorError";
-    this.url = url;
-    this.status = status;
-    this.message = message || text;
-    this.data = data;
-  }
-};
-var VigorFetch = class _VigorFetch {
-  constructor(origin, config) {
-    this._origin = origin;
-    this._config = config || {
-      path: "",
-      method: null,
-      offset: {},
-      headers: {},
-      body: null,
-      count: 5,
-      max: 5e3,
-      wait: 1e4,
-      backoff: 1.3,
-      unretry: /* @__PURE__ */ new Set([400, 401, 403, 404, 405, 413, 422]),
-      retryHeader: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
-      original: false,
-      parse: null,
-      query: {},
-      jitter: 500,
-      beforeRequest: [],
-      afterRequest: [],
-      beforeResponse: [],
-      afterResponse: [],
-      onError: []
-    };
-  }
-  _next(changes) {
-    return new _VigorFetch(this._origin, { ...this._config, ...changes });
-  }
-  path(arg) {
-    return this._next({ path: arg });
-  }
-  method(arg) {
-    return this._next({ method: arg });
-  }
-  offset(arg) {
-    return this._next({ offset: arg });
-  }
-  headers(arg) {
-    return this._next({ headers: arg });
-  }
-  body(arg) {
-    return this._next({ body: arg });
-  }
-  count(arg) {
-    return this._next({ count: arg });
-  }
-  max(arg) {
-    return this._next({ max: arg });
-  }
-  wait(arg) {
-    return this._next({ wait: arg });
-  }
-  backoff(arg) {
-    return this._next({ backoff: arg });
-  }
-  unretry(arg) {
-    return this._next({ unretry: new Set(arg) });
-  }
-  retryHeader(...arg) {
-    return this._next({ retryHeader: [...this._config.retryHeader, ...arg] });
-  }
-  original(arg) {
-    return this._next({ original: arg });
-  }
-  parse(arg) {
-    return this._next({ parse: arg });
-  }
-  query(arg) {
-    return this._next({ query: { ...this._config.query, ...arg } });
-  }
-  jitter(arg) {
-    return this._next({ jitter: arg });
-  }
-  beforeRequest(...arg) {
-    return this._next({ beforeRequest: [...this._config.beforeRequest, ...arg] });
-  }
-  afterRequest(...arg) {
-    return this._next({ afterRequest: [...this._config.afterRequest, ...arg] });
-  }
-  beforeResponse(...arg) {
-    return this._next({ beforeResponse: [...this._config.beforeResponse, ...arg] });
-  }
-  afterResponse(...arg) {
-    return this._next({ afterResponse: [...this._config.afterResponse, ...arg] });
-  }
-  onError(...arg) {
-    return this._next({ onError: [...this._config.onError, ...arg] });
-  }
-  async request() {
-    const {
-      path,
-      method,
-      offset,
-      headers,
-      body,
-      query,
-      count,
-      max,
-      wait,
-      backoff,
-      unretry,
-      jitter,
-      original,
-      parse,
-      retryHeader,
-      beforeRequest,
-      afterRequest,
-      beforeResponse,
-      afterResponse,
-      onError
-    } = this._config;
-    try {
-      if (!/^(https?|data|blob|file|about):\/\//.test(this._origin)) {
-        throw new VigorError(`[vigor] ${this._origin} >> Invalid Protocol`, {
-          url: this._origin,
-          status: 0,
-          message: "Invalid Protocol"
-        });
-      }
-      const urlObj = new URL(path.replace(/^\//, ""), this._origin + "/");
-      Object.entries(query).forEach(([key, value]) => {
-        if (value !== null && value !== void 0) urlObj.searchParams.append(key, String(value));
-      });
-      const url = urlObj.href;
-      const isJson = Array.isArray(body) || !!body && Object.getPrototypeOf(body) === Object.prototype;
-      const waitTimeout = (time) => new Promise((resolve) => setTimeout(resolve, time));
-      let option = {
-        ...offset,
-        method: method || (body ? "POST" : "GET"),
-        headers: { ...isJson && { "Content-Type": "application/json" }, ...headers },
-        ...body && { body: isJson ? JSON.stringify(body) : body }
-      };
-      for (const hook of beforeRequest) {
-        const modified = await hook(option);
-        if (modified) option = { ...option, ...modified };
-      }
-      let req;
-      for (let i = 0; i < count; i++) {
-        const controller = new AbortController();
-        const abort = setTimeout(() => controller.abort(), max);
-        option.signal = controller.signal;
+Object.defineProperty(exports, "__esModule", { value: true });
+class VigorError extends Error {
+    constructor(text, { url = null, status = 0, message, data = null }) {
+        super(text);
+        this.name = "VigorError";
+        this.url = url;
+        this.status = status;
+        this.message = message || text;
+        this.data = data;
+    }
+}
+class VigorFetch {
+    constructor(origin, config) {
+        this._origin = origin;
+        this._config = config || {
+            path: "", method: null, offset: {}, headers: {}, body: null,
+            count: 5, max: 5000, wait: 10000, backoff: 1.3,
+            unretry: new Set([400, 401, 403, 404, 405, 413, 422]),
+            retryHeader: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
+            original: false, parse: null, query: {}, jitter: 500,
+            beforeRequest: [], afterRequest: [], beforeResponse: [], afterResponse: [], onError: []
+        };
+    }
+    _next(changes) {
+        return new VigorFetch(this._origin, { ...this._config, ...changes });
+    }
+    path(arg) { return this._next({ path: arg }); }
+    method(arg) { return this._next({ method: arg }); }
+    offset(arg) { return this._next({ offset: arg }); }
+    headers(arg) { return this._next({ headers: arg }); }
+    body(arg) { return this._next({ body: arg }); }
+    count(arg) { return this._next({ count: arg }); }
+    max(arg) { return this._next({ max: arg }); }
+    wait(arg) { return this._next({ wait: arg }); }
+    backoff(arg) { return this._next({ backoff: arg }); }
+    unretry(arg) { return this._next({ unretry: new Set(arg) }); }
+    retryHeader(...arg) { return this._next({ retryHeader: [...this._config.retryHeader, ...arg] }); }
+    original(arg) { return this._next({ original: arg }); }
+    parse(arg) { return this._next({ parse: arg }); }
+    query(arg) { return this._next({ query: { ...this._config.query, ...arg } }); }
+    jitter(arg) { return this._next({ jitter: arg }); }
+    beforeRequest(...arg) { return this._next({ beforeRequest: [...this._config.beforeRequest, ...arg] }); }
+    afterRequest(...arg) { return this._next({ afterRequest: [...this._config.afterRequest, ...arg] }); }
+    beforeResponse(...arg) { return this._next({ beforeResponse: [...this._config.beforeResponse, ...arg] }); }
+    afterResponse(...arg) { return this._next({ afterResponse: [...this._config.afterResponse, ...arg] }); }
+    onError(...arg) { return this._next({ onError: [...this._config.onError, ...arg] }); }
+    async request() {
+        const { path, method, offset, headers, body, query, count, max, wait, backoff, unretry, jitter, original, parse, retryHeader, beforeRequest, afterRequest, beforeResponse, afterResponse, onError, } = this._config;
         try {
-          req = await fetch(url, option);
-          for (const hook of afterRequest) {
-            req = await hook(req) || req;
-          }
-          if (req.ok) {
-            clearTimeout(abort);
-            break;
-          }
-        } catch (error) {
-          clearTimeout(abort);
-          if (i === count - 1) throw new VigorError(`[vigor] ${url} >> Network Error`, { url, status: 0, message: "Network Error" });
-        } finally {
-          clearTimeout(abort);
+            if (!/^(https?|data|blob|file|about):\/\//.test(this._origin)) {
+                throw new VigorError(`[vigor] ${this._origin} >> Invalid Protocol`, {
+                    url: this._origin, status: 0, message: "Invalid Protocol"
+                });
+            }
+            const urlObj = new URL(path.replace(/^\//, ""), this._origin + "/");
+            Object.entries(query).forEach(([key, value]) => {
+                if (value !== null && value !== undefined)
+                    urlObj.searchParams.append(key, String(value));
+            });
+            const url = urlObj.href;
+            const isJson = Array.isArray(body) || (!!body && Object.getPrototypeOf(body) === Object.prototype);
+            const waitTimeout = (time) => new Promise(resolve => setTimeout(resolve, time));
+            let option = {
+                ...offset,
+                method: method || (body ? "POST" : "GET"),
+                headers: { ...(isJson && { "Content-Type": "application/json" }), ...headers },
+                ...(body && { body: isJson ? JSON.stringify(body) : body }),
+            };
+            for (const hook of beforeRequest) {
+                const modified = await hook(option);
+                if (modified)
+                    option = { ...option, ...modified };
+            }
+            let req;
+            for (let i = 0; i < count; i++) {
+                const controller = new AbortController();
+                const abort = setTimeout(() => controller.abort(), max);
+                option.signal = controller.signal;
+                try {
+                    req = await fetch(url, option);
+                    for (const hook of afterRequest) {
+                        req = (await hook(req)) || req;
+                    }
+                    if (req.ok) {
+                        clearTimeout(abort);
+                        break;
+                    }
+                }
+                catch (error) {
+                    clearTimeout(abort);
+                    if (i === count - 1)
+                        throw new VigorError(`[vigor] ${url} >> Network Error`, { url, status: 0, message: "Network Error" });
+                }
+                finally {
+                    clearTimeout(abort);
+                }
+                if (req) {
+                    const status = req.status;
+                    if (unretry.has(status))
+                        throw new VigorError(`[vigor] ${url} >> Unretry ${status}`, { url, status, message: "Unretry", data: status });
+                    const basic = Math.min(Math.pow(backoff, i) * 1000, wait) + Math.random() * jitter;
+                    if (status === 429) {
+                        const rHeader = retryHeader.map(h => req?.headers.get(h)).find(Boolean);
+                        const delay = rHeader ? (isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1000) : 0;
+                        const parsedDelay = Math.max(0, delay) + Math.random() * jitter;
+                        if (parsedDelay > wait)
+                            throw new VigorError(`[vigor] ${url} >> Timeouted ${parsedDelay}ms`, { url, status, message: "Timeouted", data: parsedDelay });
+                        await waitTimeout(parsedDelay || basic);
+                    }
+                    else {
+                        await waitTimeout(basic);
+                    }
+                }
+            }
+            if (!req)
+                throw new Error("No response");
+            let currentReq = req;
+            for (const hook of beforeResponse) {
+                currentReq = await hook(currentReq);
+            }
+            if (!currentReq.ok)
+                throw new VigorError(`[vigor] ${url} >> Failed`, { url, status: currentReq.status, message: "Failed" });
+            let res = await (async () => {
+                if (original)
+                    return currentReq;
+                if (parse) {
+                    const target = currentReq[parse];
+                    return typeof target === 'function' ? await target.call(currentReq) : target;
+                }
+                const contentType = currentReq.headers.get("Content-Type") || "";
+                if (/json/.test(contentType))
+                    return await currentReq.json();
+                if (/(image|video|audio|pdf)/.test(contentType))
+                    return await currentReq.blob();
+                return await currentReq.text();
+            })();
+            for (const hook of afterResponse) {
+                res = await hook(res);
+            }
+            return res;
         }
-        if (req) {
-          const status = req.status;
-          if (unretry.has(status)) throw new VigorError(`[vigor] ${url} >> Unretry ${status}`, { url, status, message: "Unretry", data: status });
-          const basic = Math.min(Math.pow(backoff, i) * 1e3, wait) + Math.random() * jitter;
-          if (status === 429) {
-            const rHeader = retryHeader.map((h) => req?.headers.get(h)).find(Boolean);
-            const delay = rHeader ? isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1e3 : 0;
-            const parsedDelay = Math.max(0, delay) + Math.random() * jitter;
-            if (parsedDelay > wait) throw new VigorError(`[vigor] ${url} >> Timeouted ${parsedDelay}ms`, { url, status, message: "Timeouted", data: parsedDelay });
-            await waitTimeout(parsedDelay || basic);
-          } else {
-            await waitTimeout(basic);
-          }
+        catch (error) {
+            let currentError = error;
+            for (const hook of onError) {
+                const result = await hook(currentError);
+                if (result !== undefined && !(result instanceof Error))
+                    return result;
+                currentError = result || currentError;
+            }
+            throw currentError;
         }
-      }
-      if (!req) throw new Error("No response");
-      let currentReq = req;
-      for (const hook of beforeResponse) {
-        currentReq = await hook(currentReq);
-      }
-      if (!currentReq.ok) throw new VigorError(`[vigor] ${url} >> Failed`, { url, status: currentReq.status, message: "Failed" });
-      let res = await (async () => {
-        if (original) return currentReq;
-        if (parse) {
-          const target = currentReq[parse];
-          return typeof target === "function" ? await target.call(currentReq) : target;
+    }
+}
+class VigorAll {
+    constructor(config) {
+        this._config = config || { limit: 10, jitter: 1000, promises: [] };
+    }
+    _next(changes) { return new VigorAll({ ...this._config, ...changes }); }
+    limit(arg) { return this._next({ limit: arg }); }
+    jitter(arg) { return this._next({ jitter: arg }); }
+    promises(...args) { return this._next({ promises: [...this._config.promises, ...args] }); }
+    async request() {
+        const { limit, jitter, promises } = this._config;
+        const results = [];
+        const executing = new Set();
+        for (const task of promises) {
+            const p = Promise.resolve()
+                .then(() => new Promise(res => setTimeout(res, Math.random() * jitter)))
+                .then(() => task());
+            results.push(p);
+            executing.add(p);
+            p.finally(() => executing.delete(p));
+            if (executing.size >= limit)
+                await Promise.race(executing);
         }
-        const contentType = currentReq.headers.get("Content-Type") || "";
-        if (/json/.test(contentType)) return await currentReq.json();
-        if (/(image|video|audio|pdf)/.test(contentType)) return await currentReq.blob();
-        return await currentReq.text();
-      })();
-      for (const hook of afterResponse) {
-        res = await hook(res);
-      }
-      return res;
-    } catch (error) {
-      let currentError = error;
-      for (const hook of onError) {
-        const result = await hook(currentError);
-        if (result !== void 0 && !(result instanceof Error)) return result;
-        currentError = result || currentError;
-      }
-      throw currentError;
+        const ready = await Promise.allSettled(results);
+        return ready.map(i => {
+            if (i.status === "fulfilled")
+                return i.value;
+            return i.reason instanceof VigorError ? i.reason : new VigorError(i.reason?.message || "Unknown", { message: i.reason?.message || "Unknown" });
+        });
+    }
+}
+class Vigor {
+    fetch(origin, config) {
+        return new VigorFetch(origin, config);
     }
-  }
-};
-var VigorAll = class _VigorAll {
-  constructor(config) {
-    this._config = config || { limit: 10, jitter: 1e3, promises: [] };
-  }
-  _next(changes) {
-    return new _VigorAll({ ...this._config, ...changes });
-  }
-  limit(arg) {
-    return this._next({ limit: arg });
-  }
-  jitter(arg) {
-    return this._next({ jitter: arg });
-  }
-  promises(...args) {
-    return this._next({ promises: [...this._config.promises, ...args] });
-  }
-  async request() {
-    const { limit, jitter, promises } = this._config;
-    const results = [];
-    const executing = /* @__PURE__ */ new Set();
-    for (const task of promises) {
-      const p = Promise.resolve().then(() => new Promise((res) => setTimeout(res, Math.random() * jitter))).then(() => task());
-      results.push(p);
-      executing.add(p);
-      p.finally(() => executing.delete(p));
-      if (executing.size >= limit) await Promise.race(executing);
+    all(config) {
+        return new VigorAll(config);
     }
-    const ready = await Promise.allSettled(results);
-    return ready.map((i) => {
-      if (i.status === "fulfilled") return i.value;
-      return i.reason instanceof VigorError ? i.reason : new VigorError(i.reason?.message || "Unknown", { message: i.reason?.message || "Unknown" });
-    });
-  }
-};
-var Vigor = class {
-  fetch(origin, config) {
-    return new VigorFetch(origin, config);
-  }
-  all(config) {
-    return new VigorAll(config);
-  }
-};
-var index_default = Vigor;
+}
+exports.default = Vigor;

package/dist/index.mjs

@@ -1,261 +1,192 @@
-// src/index.ts
-var VigorError = class extends Error {
-  constructor(text, { url = null, status = 0, message, data = null }) {
-    super(text);
-    this.name = "VigorError";
-    this.url = url;
-    this.status = status;
-    this.message = message || text;
-    this.data = data;
-  }
-};
-var VigorFetch = class _VigorFetch {
-  constructor(origin, config) {
-    this._origin = origin;
-    this._config = config || {
-      path: "",
-      method: null,
-      offset: {},
-      headers: {},
-      body: null,
-      count: 5,
-      max: 5e3,
-      wait: 1e4,
-      backoff: 1.3,
-      unretry: /* @__PURE__ */ new Set([400, 401, 403, 404, 405, 413, 422]),
-      retryHeader: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
-      original: false,
-      parse: null,
-      query: {},
-      jitter: 500,
-      beforeRequest: [],
-      afterRequest: [],
-      beforeResponse: [],
-      afterResponse: [],
-      onError: []
-    };
-  }
-  _next(changes) {
-    return new _VigorFetch(this._origin, { ...this._config, ...changes });
-  }
-  path(arg) {
-    return this._next({ path: arg });
-  }
-  method(arg) {
-    return this._next({ method: arg });
-  }
-  offset(arg) {
-    return this._next({ offset: arg });
-  }
-  headers(arg) {
-    return this._next({ headers: arg });
-  }
-  body(arg) {
-    return this._next({ body: arg });
-  }
-  count(arg) {
-    return this._next({ count: arg });
-  }
-  max(arg) {
-    return this._next({ max: arg });
-  }
-  wait(arg) {
-    return this._next({ wait: arg });
-  }
-  backoff(arg) {
-    return this._next({ backoff: arg });
-  }
-  unretry(arg) {
-    return this._next({ unretry: new Set(arg) });
-  }
-  retryHeader(...arg) {
-    return this._next({ retryHeader: [...this._config.retryHeader, ...arg] });
-  }
-  original(arg) {
-    return this._next({ original: arg });
-  }
-  parse(arg) {
-    return this._next({ parse: arg });
-  }
-  query(arg) {
-    return this._next({ query: { ...this._config.query, ...arg } });
-  }
-  jitter(arg) {
-    return this._next({ jitter: arg });
-  }
-  beforeRequest(...arg) {
-    return this._next({ beforeRequest: [...this._config.beforeRequest, ...arg] });
-  }
-  afterRequest(...arg) {
-    return this._next({ afterRequest: [...this._config.afterRequest, ...arg] });
-  }
-  beforeResponse(...arg) {
-    return this._next({ beforeResponse: [...this._config.beforeResponse, ...arg] });
-  }
-  afterResponse(...arg) {
-    return this._next({ afterResponse: [...this._config.afterResponse, ...arg] });
-  }
-  onError(...arg) {
-    return this._next({ onError: [...this._config.onError, ...arg] });
-  }
-  async request() {
-    const {
-      path,
-      method,
-      offset,
-      headers,
-      body,
-      query,
-      count,
-      max,
-      wait,
-      backoff,
-      unretry,
-      jitter,
-      original,
-      parse,
-      retryHeader,
-      beforeRequest,
-      afterRequest,
-      beforeResponse,
-      afterResponse,
-      onError
-    } = this._config;
-    try {
-      if (!/^(https?|data|blob|file|about):\/\//.test(this._origin)) {
-        throw new VigorError(`[vigor] ${this._origin} >> Invalid Protocol`, {
-          url: this._origin,
-          status: 0,
-          message: "Invalid Protocol"
-        });
-      }
-      const urlObj = new URL(path.replace(/^\//, ""), this._origin + "/");
-      Object.entries(query).forEach(([key, value]) => {
-        if (value !== null && value !== void 0) urlObj.searchParams.append(key, String(value));
-      });
-      const url = urlObj.href;
-      const isJson = Array.isArray(body) || !!body && Object.getPrototypeOf(body) === Object.prototype;
-      const waitTimeout = (time) => new Promise((resolve) => setTimeout(resolve, time));
-      let option = {
-        ...offset,
-        method: method || (body ? "POST" : "GET"),
-        headers: { ...isJson && { "Content-Type": "application/json" }, ...headers },
-        ...body && { body: isJson ? JSON.stringify(body) : body }
-      };
-      for (const hook of beforeRequest) {
-        const modified = await hook(option);
-        if (modified) option = { ...option, ...modified };
-      }
-      let req;
-      for (let i = 0; i < count; i++) {
-        const controller = new AbortController();
-        const abort = setTimeout(() => controller.abort(), max);
-        option.signal = controller.signal;
+Object.defineProperty(exports, "__esModule", { value: true });
+class VigorError extends Error {
+    constructor(text, { url = null, status = 0, message, data = null }) {
+        super(text);
+        this.name = "VigorError";
+        this.url = url;
+        this.status = status;
+        this.message = message || text;
+        this.data = data;
+    }
+}
+class VigorFetch {
+    constructor(origin, config) {
+        this._origin = origin;
+        this._config = config || {
+            path: "", method: null, offset: {}, headers: {}, body: null,
+            count: 5, max: 5000, wait: 10000, backoff: 1.3,
+            unretry: new Set([400, 401, 403, 404, 405, 413, 422]),
+            retryHeader: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
+            original: false, parse: null, query: {}, jitter: 500,
+            beforeRequest: [], afterRequest: [], beforeResponse: [], afterResponse: [], onError: []
+        };
+    }
+    _next(changes) {
+        return new VigorFetch(this._origin, { ...this._config, ...changes });
+    }
+    path(arg) { return this._next({ path: arg }); }
+    method(arg) { return this._next({ method: arg }); }
+    offset(arg) { return this._next({ offset: arg }); }
+    headers(arg) { return this._next({ headers: arg }); }
+    body(arg) { return this._next({ body: arg }); }
+    count(arg) { return this._next({ count: arg }); }
+    max(arg) { return this._next({ max: arg }); }
+    wait(arg) { return this._next({ wait: arg }); }
+    backoff(arg) { return this._next({ backoff: arg }); }
+    unretry(arg) { return this._next({ unretry: new Set(arg) }); }
+    retryHeader(...arg) { return this._next({ retryHeader: [...this._config.retryHeader, ...arg] }); }
+    original(arg) { return this._next({ original: arg }); }
+    parse(arg) { return this._next({ parse: arg }); }
+    query(arg) { return this._next({ query: { ...this._config.query, ...arg } }); }
+    jitter(arg) { return this._next({ jitter: arg }); }
+    beforeRequest(...arg) { return this._next({ beforeRequest: [...this._config.beforeRequest, ...arg] }); }
+    afterRequest(...arg) { return this._next({ afterRequest: [...this._config.afterRequest, ...arg] }); }
+    beforeResponse(...arg) { return this._next({ beforeResponse: [...this._config.beforeResponse, ...arg] }); }
+    afterResponse(...arg) { return this._next({ afterResponse: [...this._config.afterResponse, ...arg] }); }
+    onError(...arg) { return this._next({ onError: [...this._config.onError, ...arg] }); }
+    async request() {
+        const { path, method, offset, headers, body, query, count, max, wait, backoff, unretry, jitter, original, parse, retryHeader, beforeRequest, afterRequest, beforeResponse, afterResponse, onError, } = this._config;
         try {
-          req = await fetch(url, option);
-          for (const hook of afterRequest) {
-            req = await hook(req) || req;
-          }
-          if (req.ok) {
-            clearTimeout(abort);
-            break;
-          }
-        } catch (error) {
-          clearTimeout(abort);
-          if (i === count - 1) throw new VigorError(`[vigor] ${url} >> Network Error`, { url, status: 0, message: "Network Error" });
-        } finally {
-          clearTimeout(abort);
+            if (!/^(https?|data|blob|file|about):\/\//.test(this._origin)) {
+                throw new VigorError(`[vigor] ${this._origin} >> Invalid Protocol`, {
+                    url: this._origin, status: 0, message: "Invalid Protocol"
+                });
+            }
+            const urlObj = new URL(path.replace(/^\//, ""), this._origin + "/");
+            Object.entries(query).forEach(([key, value]) => {
+                if (value !== null && value !== undefined)
+                    urlObj.searchParams.append(key, String(value));
+            });
+            const url = urlObj.href;
+            const isJson = Array.isArray(body) || (!!body && Object.getPrototypeOf(body) === Object.prototype);
+            const waitTimeout = (time) => new Promise(resolve => setTimeout(resolve, time));
+            let option = {
+                ...offset,
+                method: method || (body ? "POST" : "GET"),
+                headers: { ...(isJson && { "Content-Type": "application/json" }), ...headers },
+                ...(body && { body: isJson ? JSON.stringify(body) : body }),
+            };
+            for (const hook of beforeRequest) {
+                const modified = await hook(option);
+                if (modified)
+                    option = { ...option, ...modified };
+            }
+            let req;
+            for (let i = 0; i < count; i++) {
+                const controller = new AbortController();
+                const abort = setTimeout(() => controller.abort(), max);
+                option.signal = controller.signal;
+                try {
+                    req = await fetch(url, option);
+                    for (const hook of afterRequest) {
+                        req = (await hook(req)) || req;
+                    }
+                    if (req.ok) {
+                        clearTimeout(abort);
+                        break;
+                    }
+                }
+                catch (error) {
+                    clearTimeout(abort);
+                    if (i === count - 1)
+                        throw new VigorError(`[vigor] ${url} >> Network Error`, { url, status: 0, message: "Network Error" });
+                }
+                finally {
+                    clearTimeout(abort);
+                }
+                if (req) {
+                    const status = req.status;
+                    if (unretry.has(status))
+                        throw new VigorError(`[vigor] ${url} >> Unretry ${status}`, { url, status, message: "Unretry", data: status });
+                    const basic = Math.min(Math.pow(backoff, i) * 1000, wait) + Math.random() * jitter;
+                    if (status === 429) {
+                        const rHeader = retryHeader.map(h => req?.headers.get(h)).find(Boolean);
+                        const delay = rHeader ? (isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1000) : 0;
+                        const parsedDelay = Math.max(0, delay) + Math.random() * jitter;
+                        if (parsedDelay > wait)
+                            throw new VigorError(`[vigor] ${url} >> Timeouted ${parsedDelay}ms`, { url, status, message: "Timeouted", data: parsedDelay });
+                        await waitTimeout(parsedDelay || basic);
+                    }
+                    else {
+                        await waitTimeout(basic);
+                    }
+                }
+            }
+            if (!req)
+                throw new Error("No response");
+            let currentReq = req;
+            for (const hook of beforeResponse) {
+                currentReq = await hook(currentReq);
+            }
+            if (!currentReq.ok)
+                throw new VigorError(`[vigor] ${url} >> Failed`, { url, status: currentReq.status, message: "Failed" });
+            let res = await (async () => {
+                if (original)
+                    return currentReq;
+                if (parse) {
+                    const target = currentReq[parse];
+                    return typeof target === 'function' ? await target.call(currentReq) : target;
+                }
+                const contentType = currentReq.headers.get("Content-Type") || "";
+                if (/json/.test(contentType))
+                    return await currentReq.json();
+                if (/(image|video|audio|pdf)/.test(contentType))
+                    return await currentReq.blob();
+                return await currentReq.text();
+            })();
+            for (const hook of afterResponse) {
+                res = await hook(res);
+            }
+            return res;
         }
-        if (req) {
-          const status = req.status;
-          if (unretry.has(status)) throw new VigorError(`[vigor] ${url} >> Unretry ${status}`, { url, status, message: "Unretry", data: status });
-          const basic = Math.min(Math.pow(backoff, i) * 1e3, wait) + Math.random() * jitter;
-          if (status === 429) {
-            const rHeader = retryHeader.map((h) => req?.headers.get(h)).find(Boolean);
-            const delay = rHeader ? isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1e3 : 0;
-            const parsedDelay = Math.max(0, delay) + Math.random() * jitter;
-            if (parsedDelay > wait) throw new VigorError(`[vigor] ${url} >> Timeouted ${parsedDelay}ms`, { url, status, message: "Timeouted", data: parsedDelay });
-            await waitTimeout(parsedDelay || basic);
-          } else {
-            await waitTimeout(basic);
-          }
+        catch (error) {
+            let currentError = error;
+            for (const hook of onError) {
+                const result = await hook(currentError);
+                if (result !== undefined && !(result instanceof Error))
+                    return result;
+                currentError = result || currentError;
+            }
+            throw currentError;
         }
-      }
-      if (!req) throw new Error("No response");
-      let currentReq = req;
-      for (const hook of beforeResponse) {
-        currentReq = await hook(currentReq);
-      }
-      if (!currentReq.ok) throw new VigorError(`[vigor] ${url} >> Failed`, { url, status: currentReq.status, message: "Failed" });
-      let res = await (async () => {
-        if (original) return currentReq;
-        if (parse) {
-          const target = currentReq[parse];
-          return typeof target === "function" ? await target.call(currentReq) : target;
+    }
+}
+class VigorAll {
+    constructor(config) {
+        this._config = config || { limit: 10, jitter: 1000, promises: [] };
+    }
+    _next(changes) { return new VigorAll({ ...this._config, ...changes }); }
+    limit(arg) { return this._next({ limit: arg }); }
+    jitter(arg) { return this._next({ jitter: arg }); }
+    promises(...args) { return this._next({ promises: [...this._config.promises, ...args] }); }
+    async request() {
+        const { limit, jitter, promises } = this._config;
+        const results = [];
+        const executing = new Set();
+        for (const task of promises) {
+            const p = Promise.resolve()
+                .then(() => new Promise(res => setTimeout(res, Math.random() * jitter)))
+                .then(() => task());
+            results.push(p);
+            executing.add(p);
+            p.finally(() => executing.delete(p));
+            if (executing.size >= limit)
+                await Promise.race(executing);
         }
-        const contentType = currentReq.headers.get("Content-Type") || "";
-        if (/json/.test(contentType)) return await currentReq.json();
-        if (/(image|video|audio|pdf)/.test(contentType)) return await currentReq.blob();
-        return await currentReq.text();
-      })();
-      for (const hook of afterResponse) {
-        res = await hook(res);
-      }
-      return res;
-    } catch (error) {
-      let currentError = error;
-      for (const hook of onError) {
-        const result = await hook(currentError);
-        if (result !== void 0 && !(result instanceof Error)) return result;
-        currentError = result || currentError;
-      }
-      throw currentError;
+        const ready = await Promise.allSettled(results);
+        return ready.map(i => {
+            if (i.status === "fulfilled")
+                return i.value;
+            return i.reason instanceof VigorError ? i.reason : new VigorError(i.reason?.message || "Unknown", { message: i.reason?.message || "Unknown" });
+        });
+    }
+}
+class Vigor {
+    fetch(origin, config) {
+        return new VigorFetch(origin, config);
     }
-  }
-};
-var VigorAll = class _VigorAll {
-  constructor(config) {
-    this._config = config || { limit: 10, jitter: 1e3, promises: [] };
-  }
-  _next(changes) {
-    return new _VigorAll({ ...this._config, ...changes });
-  }
-  limit(arg) {
-    return this._next({ limit: arg });
-  }
-  jitter(arg) {
-    return this._next({ jitter: arg });
-  }
-  promises(...args) {
-    return this._next({ promises: [...this._config.promises, ...args] });
-  }
-  async request() {
-    const { limit, jitter, promises } = this._config;
-    const results = [];
-    const executing = /* @__PURE__ */ new Set();
-    for (const task of promises) {
-      const p = Promise.resolve().then(() => new Promise((res) => setTimeout(res, Math.random() * jitter))).then(() => task());
-      results.push(p);
-      executing.add(p);
-      p.finally(() => executing.delete(p));
-      if (executing.size >= limit) await Promise.race(executing);
+    all(config) {
+        return new VigorAll(config);
     }
-    const ready = await Promise.allSettled(results);
-    return ready.map((i) => {
-      if (i.status === "fulfilled") return i.value;
-      return i.reason instanceof VigorError ? i.reason : new VigorError(i.reason?.message || "Unknown", { message: i.reason?.message || "Unknown" });
-    });
-  }
-};
-var Vigor = class {
-  fetch(origin, config) {
-    return new VigorFetch(origin, config);
-  }
-  all(config) {
-    return new VigorAll(config);
-  }
-};
-var index_default = Vigor;
-export {
-  index_default as default
-};
+}
+exports.default = Vigor;

package/package.json

@@ -1,16 +1,23 @@
 {
   "name": "vigor-fetch",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Smart, zero-dependency HTTP client with self-healing retries for rate-limited servers.",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
-    "dev": "tsup src/index.ts --format cjs,esm --watch --dts"
+    "build": "rollup -c",
+    "dev": "rollup -c -w"
   },
   "keywords": [
     "fetch",
@@ -24,7 +31,9 @@
   "author": "Uav1010",
   "license": "MIT",
   "devDependencies": {
-    "tsup": "^8.5.1",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "rollup": "^4.59.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.9.3"
   },
   "engines": {

package/dist/index.d.mts

@@ -1,75 +0,0 @@
-interface VigorErrorOptions {
-    url?: string | null;
-    status?: number;
-    message?: string;
-    data?: any;
-}
-interface VigorFetchConfig {
-    path: string;
-    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | null;
-    offset: RequestInit;
-    headers: Record<string, string>;
-    body: any;
-    count: number;
-    max: number;
-    wait: number;
-    backoff: number;
-    unretry: Set<number>;
-    retryHeader: string[];
-    original: boolean;
-    parse: keyof Response | null;
-    beforeRequest: Array<(opt: RequestInit) => Promise<Partial<RequestInit> | void> | Partial<RequestInit> | void>;
-    afterRequest: Array<(res: Response) => Promise<Response | void> | Response | void>;
-    beforeResponse: Array<(res: Response) => Promise<Response> | Response>;
-    afterResponse: Array<(data: any) => Promise<any> | any>;
-    onError: Array<(err: any) => Promise<any> | any>;
-    query: Record<string, any>;
-    jitter: number;
-}
-declare class VigorFetch<T = any> {
-    private _origin;
-    private _config;
-    constructor(origin: string, config?: VigorFetchConfig);
-    private _next;
-    path(arg: string): VigorFetch<T>;
-    method(arg: VigorFetchConfig['method']): VigorFetch<T>;
-    offset(arg: RequestInit): VigorFetch<T>;
-    headers(arg: Record<string, string>): VigorFetch<T>;
-    body(arg: any): VigorFetch<T>;
-    count(arg: number): VigorFetch<T>;
-    max(arg: number): VigorFetch<T>;
-    wait(arg: number): VigorFetch<T>;
-    backoff(arg: number): VigorFetch<T>;
-    unretry(arg: number[]): VigorFetch<T>;
-    retryHeader(...arg: string[]): VigorFetch<T>;
-    original(arg: boolean): VigorFetch<T>;
-    parse(arg: keyof Response): VigorFetch<T>;
-    query(arg: Record<string, any>): VigorFetch<T>;
-    jitter(arg: number): VigorFetch<T>;
-    beforeRequest(...arg: VigorFetchConfig['beforeRequest']): VigorFetch<T>;
-    afterRequest(...arg: VigorFetchConfig['afterRequest']): VigorFetch<T>;
-    beforeResponse(...arg: VigorFetchConfig['beforeResponse']): VigorFetch<T>;
-    afterResponse(...arg: VigorFetchConfig['afterResponse']): VigorFetch<T>;
-    onError(...arg: VigorFetchConfig['onError']): VigorFetch<T>;
-    request(): Promise<T>;
-}
-interface VigorAllConfig {
-    limit: number;
-    jitter: number;
-    promises: Array<() => Promise<any>>;
-}
-declare class VigorAll {
-    private _config;
-    constructor(config?: VigorAllConfig);
-    private _next;
-    limit(arg: number): VigorAll;
-    jitter(arg: number): VigorAll;
-    promises(...args: Array<() => Promise<any>>): VigorAll;
-    request(): Promise<any[]>;
-}
-declare class Vigor {
-    fetch<T = any>(origin: string, config?: VigorFetchConfig): VigorFetch<T>;
-    all(config?: VigorAllConfig): VigorAll;
-}
-
-export { type VigorAllConfig, type VigorErrorOptions, type VigorFetchConfig, Vigor as default };