vigor-fetch 1.0.1 → 1.0.3

package/README.md

@@ -8,57 +8,126 @@
 - 📈 **Exponential Backoff & Jitter:** Prevents server hammering by increasing wait times with random variation.
 - ⚡ **Zero Dependencies:** Built using native Fetch API and AbortController.
 - 🎯 **Fully Type-Safe:** Written in TypeScript for excellent developer experience and auto-completion.
+- 🚦 **Concurrency Control**: Execute bulk requests with a global limit and inter-request jitter using the VigorAll engine.
+- 🎯 **Immutable Chaining**: Every configuration method returns a new instance, making it perfect for base templates and functional patterns.
 
 ## 📦 Installation
 
 npm install vigor-fetch
 
+## 🛠️ API References
+
+1. Vigor().fetch(origin, config)
+
+| Method | Type | Default | Description
+| :--- | :--- | :--- | :--- |
+| .path(arg) | string | "" | Sets the endpoint path to be appended to the origin. |
+| .query(arg) | Record<string, any> | {} | Appends key-value pairs as query parameters to the URL. |
+| .headers(arg) | Record<string, string> | {} | Sets the HTTP request headers. |
+| .body(arg) | any | null | Sets the request body |
+| .offset(arg) | RequestInit | {} | Provides raw fetch options to be merged into the request. |
+| .count(arg) | number | 5 | Specifies the maximum number of retry attempts for the request. |
+| .max(arg) | number | 5000 | Sets the timeout (in ms) for each individual request attempt. |
+| .wait(arg) | number | 10000 | Sets the maximum wait time (in ms) between retry attempts. |
+| .backoff(arg) | number | 1.3 | The multiplier used for exponential backoff between retries. |
+| .jitter(arg) | number | 500 | Adds a random delay (up to this value in ms) to prevent thundering herd issues. |
+| .unretry(arg[]) | number[] | [400, 401, 403, 404, 405, 413, 422] | List of HTTP status codes that should NOT trigger a retry. |
+| .retryHeader(...arg) | string[] | ['retry-after', ...] | Custom headers to check for server-defined retry delays |
+| .original(bool) | boolean | false | If true, returns the raw Response object instead of parsed data. |
+| .parse(key) | keyof Response | null | Forces the use of a specific Response method (e.g., 'json', 'blob') for parsing. |
+| .beforeRequest(...hooks) | Function[] | [] | Hooks executed to modify request options before the fetch occurs. |
+| .afterRequest(...hooks) | Function[] | [] | Hooks executed immediately after the fetch, before the status check. |
+| .beforeResponse(...hooks) | Function[] | [] | Hooks executed on the Response object before parsing the body. |
+| .afterResponse(...hooks) | Function[] | [] | Hooks executed on the parsed data before returning the final result. |
+| .onError(...hooks) | Function[] | [] | Hooks to handle errors; can recover from error by returning a value. |
+| .request() | Promise<T> | - | Executes the request logic including retries and hooks. |
+
+2. Vigor().all(config)
+| Method | Type | Default | Description
+| :--- | :--- | :--- | :--- |
+| .limit(arg) | number | 10 | Maximum number of concurrent promises running at once. |
+| .jitter(arg) | number | 1000 | Random delay (ms) applied before each task starts. |
+| .promises(...args) | Function[] | [] | Adds functions that return promises to the execution queue. |
+| .request() | Promise<any[]> | - | Executes all tasks with concurrency control and returns results. |
+
 ## 🚀 Quick Start
 
-```
+```javascript
 
 import Vigor from 'vigor-fetch';
 
-const api = new Vigor("https://api.example.com")
-  .path("/v1/data")
+const vigor = new Vigor();
+
+const data = await vigor.fetch("https://api.example.com")
+  .path("/v1/users")
   .method("POST")
-  .headers({ "X-API-KEY": "123" })
-  .query({ limit: 10, page: 1 })
+  .headers({ "Authorization": "Bearer TOKEN" })
   .body({ name: "Uav1010" })
-  .count(5)
-  .max(5000)
-  .wait(10000)
-  .backoff(1.5)
-  .jitter(500)
-  .unretry([401, 404])
-  .parse("json")
-  .beforeRequest((opt) => {
-    console.log("Sending...");
-  })
-  .afterResponse((res) => {
-    return { ...res, timestamp: Date.now() };
-  });
+  .count(5)        // Retry up to 5 times
+  .backoff(1.5)    // Multiply wait time by 1.5x each failure
+  .parse("json")   // Auto-parse response as JSON
+  .request();
 
-const data = await api.request();
+```
+
+## 🛠️ Advanced Patterns
+
+1. Request Templates
+
+```javascript
+
+import Vigor from 'vigor-fetch';
+
+const vigor = new Vigor();
+
+const apiClient = vigor.fetch("https://api.myapp.com")
+  .headers({ "Content-Type": "application/json" })
+  .unretry([401, 403, 404]) // Don't retry on these statuses
+  .max(3000); // 3s timeout per attempt
+
+const user = await apiClient.path("/me").request();
+const settings = await apiClient.path("/settings").request();
 
 ```
 
-## 🛠️ API Reference
-
-| Method | Type | Description |
-| :--- | :--- | :--- |
-| .path(string) | string | Appends path to origin. |
-| .method(string) | string | Sets HTTP method (GET, POST, etc). |
-| .query(object) | Record | Key-value pairs for URL search params. |
-| .headers(object) | Record | Custom HTTP headers. |
-| .body(any) | any | Request payload (auto-detects JSON). |
-| .count(number) | number | Max retry attempts (Default: 5). |
-| .max(ms) | number | Timeout for each fetch attempt (Default: 5000ms). |
-| .wait(ms) | number | Max delay allowed. If exceeded, throws error. |
-| .backoff(number) | number | Retry interval multiplier (Default: 1.3). |
-| .jitter(ms) | number | Randomness to avoid thundering herd (Default: 500ms). |
-| .unretry(codes[]) | number[] | Status codes that stop retrying (e.g. 404). |
-| .original(bool) | boolean | If true, returns raw Response object. |
-| .parse(type) | string | json, text, blob, arrayBuffer, formData. |
-| .beforeRequest() | function | Async hook to modify options before fetch. |
-| .afterResponse() | function | Async hook to transform data after fetch. |
+2. Batch Processing with Concurrency Limit
+
+```javascript
+
+import Vigor from 'vigor-fetch';
+
+const vigor = new Vigor();
+
+const tasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(id => () => 
+  vigor.fetch("https://api.com").path(`/data/${id}`).request()
+);
+
+const results = await vigor.all()
+  .limit(3)       // Max 3 concurrent requests
+  .jitter(500)    // Add up to 500ms random delay between starts
+  .promises(...tasks)
+  .request();
+
+```
+
+3. Middleware & Hooks
+
+```javascript
+
+import Vigor from 'vigor-fetch';
+
+const vigor = new Vigor();
+
+const api = vigor.fetch("https://api.com")
+  .beforeRequest((opt) => {
+    opt.headers = { ...opt.headers, "X-Timestamp": Date.now().toString() };
+  })
+  .afterResponse((data) => {
+    return { ...data, receivedAt: new Date() }; // Transform final result
+  })
+  .onError((err) => {
+    if (err.status === 404) return { error: "Not Found", fallback: true };
+    throw err; // Continue throwing if not handled
+  });
+
+```

package/dist/index.d.mts

@@ -0,0 +1,75 @@
+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 };

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-interface VigorConfig {
+interface VigorErrorOptions {
+    url?: string | null;
+    status?: number;
+    message?: string;
+    data?: any;
+}
+interface VigorFetchConfig {
     path: string;
-    method: string | null;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | null;
     offset: RequestInit;
     headers: Record<string, string>;
     body: any;
@@ -9,34 +15,61 @@ interface VigorConfig {
     wait: number;
     backoff: number;
     unretry: Set<number>;
+    retryHeader: string[];
     original: boolean;
     parse: keyof Response | null;
-    beforeRequest: ((option: RequestInit) => Promise<RequestInit | void> | RequestInit | void)[];
-    afterResponse: ((res: any) => Promise<any> | any)[];
-    query: Record<string, string | number | boolean | null | undefined>;
+    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;
 }
-export default class Vigor {
+declare class VigorFetch<T = any> {
     private _origin;
     private _config;
-    constructor(origin: string, config?: VigorConfig);
+    constructor(origin: string, config?: VigorFetchConfig);
     private _next;
-    path(arg: string): Vigor;
-    method(arg: string): Vigor;
-    offset(arg: RequestInit): Vigor;
-    headers(arg: Record<string, string>): Vigor;
-    body(arg: any): Vigor;
-    count(arg: number): Vigor;
-    max(arg: number): Vigor;
-    wait(arg: number): Vigor;
-    backoff(arg: number): Vigor;
-    unretry(arg: number[]): Vigor;
-    original(arg: boolean): Vigor;
-    beforeRequest(...arg: VigorConfig['beforeRequest']): Vigor;
-    afterResponse(...arg: VigorConfig['afterResponse']): Vigor;
-    parse(arg: VigorConfig['parse']): Vigor;
-    query(arg: VigorConfig['query']): Vigor;
-    jitter(arg: number): Vigor;
-    request<T = any>(): Promise<T>;
+    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 {};
+
+export { type VigorAllConfig, type VigorErrorOptions, type VigorFetchConfig, Vigor as default };

package/dist/index.js

@@ -1,158 +1,282 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class VigorError extends Error {
-    constructor(text, { url, status, message, data = null }) {
-        super(text);
-        this.name = "VigorError";
-        this.url = url;
-        this.status = status;
-        this.message = message;
-        this.data = data;
-    }
-}
-class Vigor {
-    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]),
-            original: false,
-            parse: null,
-            beforeRequest: [],
-            afterResponse: [],
-            query: {},
-            jitter: 500
-        };
-    }
-    _next(changes) {
-        return new Vigor(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) }); }
-    original(arg) { return this._next({ original: arg }); }
-    beforeRequest(...arg) {
-        return this._next({ beforeRequest: [...this._config.beforeRequest, ...arg] });
-    }
-    afterResponse(...arg) {
-        return this._next({ afterResponse: [...this._config.afterResponse, ...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 }); }
-    async request() {
-        const { path, method, offset, headers, body, count, max, wait, backoff, unretry, original, beforeRequest, afterResponse, parse, query, jitter } = this._config;
-        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));
-            }
+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, {
+  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 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);
-            option = { ...option, ...(modified || {}) };
+      }
+      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;
+        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);
         }
-        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);
-                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 retryHeaders = ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
-                    const retryAfter = retryHeaders.map(h => req?.headers.get(h)).find(Boolean);
-                    const delay = (Number(retryAfter) * 1000 || (new Date(retryAfter).getTime() - Date.now()));
-                    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) {
+          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);
+          }
         }
-        if (!req || !req.ok)
-            throw new VigorError(`[vigor] ${url} >> Failed`, {
-                url, status: req?.status || 0, message: "Failed"
-            });
-        let res = await (async () => {
-            if (original)
-                return req;
-            if (parse)
-                return await req[parse]();
-            const contentType = req.headers.get("Content-Type") || "";
-            if (/json/.test(contentType))
-                return await req.json();
-            if (/(image|video|audio|pdf)/.test(contentType))
-                return await req.blob();
-            if (/octet-stream/.test(contentType))
-                return await req.arrayBuffer();
-            if (/form-data/.test(contentType))
-                return await req.formData();
-            return await req.text();
-        })();
-        for (const hook of afterResponse) {
-            res = await hook(res);
+      }
+      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;
         }
-        return res;
+        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;
+    }
+  }
+};
+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);
     }
-}
-exports.default = Vigor;
+    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;

package/dist/index.mjs

@@ -0,0 +1,261 @@
+// 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;
+        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) * 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);
+          }
+        }
+      }
+      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;
+    } 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;
+    }
+  }
+};
+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);
+    }
+    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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigor-fetch",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Smart, zero-dependency HTTP client with self-healing retries for rate-limited servers.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -9,20 +9,22 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts"
   },
   "keywords": [
     "fetch",
+    "PromiseAll",
     "retry",
     "backoff",
     "ratelimit",
     "typescript",
     "zero-dependency"
   ],
-  "author": "Your Name",
+  "author": "Uav1010",
   "license": "MIT",
   "devDependencies": {
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "engines": {