vigor-fetch 2.2.8 → 3.0.0

package/README.md

@@ -1,466 +1,1160 @@
 # vigor-fetch
 
-**Vigor** is a lightweight (minified + gzipped ~4.3kb) TypeScript HTTP / Retry utility library.  
-Vigor provides a fluent, chainable API for building robust network logic with built-in retry, backoff, interceptors, parsing, and concurrency control.
+## Vigor is a composable, lightweighted (gzipped ~10kb) network workflow toolkit built on top of native Fetch.
+
+> Vigor provides a fluent, chainable API for building robust network logic with built-in retry, backoff, interceptors, parsing, and concurrency control.
 
 ---
 
 ## Features
 
 - 🧩 **Fluent & Immutable API** — Fully composable, side-effect-free chaining
-- 🔁 **Advanced Retry System** — Exponential backoff with jitter support.
+- 🔁 **Advanced Retry System** — Constant, linear, backoff, custom delay with jitter support.
 - 🌐 **Smart Fetch Layer** — Automatic 429 handling & configurable retry rules
 - ⚡ **Parallel Requests** — Concurrency-limited task runner
-- 🔌 **Smart Response Parsing** — Auto parsing based on Content-Type
+- 🔌 **Smart Response Parsing** — Auto parsing based on Content-Type, Sniffing
 - ⚡ **Zero Dependencies** — Built on native Fetch + AbortController
 - 🪝 **Powerful Interceptors** — Lifecycle hooks for full control flow
 - 🧠 **TypeScript First** — Fully typed inference across all modules
 
-
 ---
 
-
 ## Installation
 
 ```bash
-npm install vigor-fetch
+
+npm  install  vigor-fetch
+
 ```
 
 ## Why Vigor?
- 
-| Feature | Vigor | native fetch | ky | axios |
+
+| Feature | Vigor | Axios | Ky | Got |
 |---|:---:|:---:|:---:|:---:|
-| Zero dependencies | ✅ | ✅ | ❌ | ✅ |
-| 429 rate-limit handling | ✅ | ❌ | ✅(manual/config-based) | ❌ |
-| Retry with jitter | ✅ | ❌ | ✅ | ❌ |
-| Exponential backoff | ✅ | ❌ | ✅ | ❌ |
-| Auto response parsing | ✅ | ❌ | ✅ | ✅ |
-| Fluent chaining API | ✅ | ❌ | ✅ | ❌ |
-| Concurrency control | ✅ | ❌ | ❌ | ❌ |
-| Lifecycle interceptors | ✅ | ❌ | partial | ✅ |
-| Plugin system | ✅ | ❌ | ❌ | ❌ |
+| Runtime | Browser + Node | Browser + Node | Browser + Node | Primarily Node.js |
+| Built on Fetch | ✅ Native Fetch-based | ❌ Custom adapter-based | ✅ | ❌ |
+| Immutable Fluent Builder | ✅ | ❌ | ⚠️ Partial | ⚠️ Partial |
+| Built-in Retry Engine | ✅ Advanced | ⚠️ Limited | ✅ | ✅ |
+| Custom Retry Algorithms | ✅ | ❌ | ⚠️ Limited | ⚠️ Limited |
+| Retry Interceptors | ✅ | ❌ | ❌ | ❌ |
+| Automatic RateLimit Handling (`429`) | ✅ | ❌ | ⚠️ Partial | ✅ |
+| Automatic Content-Type Parsing | ✅ | ⚠️ Mostly JSON | ✅ | ✅ |
+| Standalone Parse Engine | ✅ | ❌ | ❌ | ❌ |
+| Custom Parsing Strategies | ✅ | ❌ | ❌ | ⚠️ Hook-level |
+| Lifecycle Interceptors | ✅ Full lifecycle | ✅ | ⚠️ Hook-based | ✅ Hook-based |
+| Concurrency Queue Engine | ✅ | ❌ | ❌ | ❌ |
+| Default Fallback Values | ✅ | ❌ | ❌ | ❌ |
 
 ## Quick Start
 
+### Fetch
+```ts  
+import vigor from "vigor-fetch";  
+
+const data = await vigor  
+	.fetch("https://api.example.com", "api")  
+	.path("v1", "main")  
+	.request();  
+// -> https://api.example.com/api/v1/main
+```
+#### Advanced
 ```ts
-import vigor from "vigor-fetch";
 const data = await vigor
   .fetch("https://api.example.com")
-  .path("api", "v1", "main")
-  .request()
+  .path("users")
+  .retryConfig(r => r
+	  .settings(s => s.attempt(5))
+  )
+  .parseConfig(p => p
+  .strategies(s => s.sniff())
+  )
+  .interceptors(i => i
+	  .onError((ctx, api) => {
+	      api.retry();
+	   })
+  )
+  .request();
+```
+
+### Retry
+```ts
+import vigor from "vigor-fetch";
+
+const data = await vigor
+	.retry(async(ctx, {signal, abort}) => {
+		return await db.select(~)
+	})
+	.request()
 ```
 
-# 🛠️ Vigor API Reference
+### Parse
+```ts  
+import vigor from "vigor-fetch";  
+  
+const response = await fetch("https://api.example.com");  
+const data = await vigor  
+	.parse(response)  
+	.request();  
+```
 
+### Concurrency  
+```ts  
+import vigor from "vigor-fetch";  
+  
+const data = await vigor  
+	.all(  
+		async () => fetch("/api/1"),  
+		async () => fetch("/api/2")  
+	)  
+	.request();  
+```
 
+## vigor.retry  
+  
+### Methods  
+  
+| Method | Description |  
+|---|---|  
+| target(fn) | Sets retry target function |  
+| settings(fn \| config) | Configures retry settings |  
+| interceptors(fn \| config) | Configures retry interceptors |  
+| algorithms(fn) | Configures retry delay algorithm |  
+| abortSignals(...signals) | Attaches external AbortSignals |  
+| request(config?) | Executes retry pipeline |  
+  
+---  
+  
+### target  
+  
+Sets the retry target.  
+  
+```ts  
+vigor.retry(async () => {  
+	return await fetch("/api");  
+})  
+```  
+  
+---  
+  
+### settings  
+  
+Configures retry behavior.  
+  
+```ts  
+.settings(s => s  
+	.attempt(10)  
+	.timeout(5000)  
+	.jitter(1000)  
+)
+```  
+  
+#### Settings API  
+  
+| Method | Description | Default |  
+|---|---|---|  
+| attempt(number) | Maximum retry attempts | `5` |  
+| timeout(ms) | Timeout per attempt | `20000` |  
+| jitter(ms) | Random retry jitter | `1000` |  
+| default(value) | Fallback return value | `throws` |  
+  
+---  
+  
+### algorithms  
+  
+Configures retry delay algorithm.  
+  
+```ts  
+.algorithms(a => a
+	.backoff()  
+	.initial(1000)  
+	.multiplier(2)  
+)  
+```  
+  
+---  
+  
+## Retry Algorithms  
+  
+### constant  
+  
+Fixed retry delay.  
+  
+```ts  
+.algorithms(a => a
+	.constant()  
+	.interval(2000)  
+)  
+```  
+  
+#### API  
+  
+| Method | Description |  
+|---|---|  
+| interval(ms) | Fixed retry interval |  
+  
+---  
+  
+### linear  
+  
+Linearly increasing delay.  
+  
+```ts  
+.algorithms(a => a
+	.linear()  
+	.initial(1000)  
+	.increment(1000)  
+)  
+```  
+  
+#### API  
+  
+| Method | Description |  
+|---|---|  
+| initial(ms) | Initial delay |  
+| increment(ms) | Delay increment |  
+| minDelay(ms) | Minimum delay |  
+| maxDelay(ms) | Maximum delay |  
+  
+---  
+  
+### backoff  
+  
+Exponential backoff delay.  
+  
+```ts  
+.algorithms(a => a
+	.backoff()  
+	.initial(1000)  
+	.multiplier(1.7)  
+)  
+```  
+  
+#### API  
+  
+| Method | Description |  
+|---|---|  
+| initial(ms) | Initial delay |  
+| multiplier(number) | Exponential multiplier |  
+| unit(ms) | Delay unit |  
+| minDelay(ms) | Minimum delay |  
+| maxDelay(ms) | Maximum delay |  
+  
+---  
+  
+### custom  
+  
+Fully custom retry algorithm.  
+  
+```ts  
+.algorithms(a => a
+	.custom()  
+	.func(attempt => {  
+		return attempt * 3000;  
+	})  
+)  
+```  
+  
+#### API  
+  
+| Method | Description |  
+|---|---|  
+| func(fn) | Custom delay calculator |  
+  
+---  
+  
+### abortSignals  
+  
+Attaches external AbortSignals.  
+  
+```ts  
+const controller = new AbortController();  
+  
+await vigor  
+	.retry(task)  
+	.abortSignals(controller.signal)  
+	.request();  
+```  
+  
+---  
+  
+### request  
+  
+Executes retry workflow.  
+  
+```ts  
+const result = await vigor  
+	.retry(task)  
+	.request();  
+```  
+  
+---  
+  
+## Interceptors  
+  
+| Name | API |  
+|---|:---:|  
+| before | throwError / breakRetry / abort |  
+| after | setResult / throwError / breakRetry |  
+| result | setResult / throwError |  
+| retryIf | proceedRetry / cancelRetry |  
+| onRetry | throwError / setDelay / setAttempt |  
+| onError | setResult / throwError / restart |  
+  
+---  
+  
+### before  
+  
+Runs before each retry attempt.  
+  
+```ts  
+.before(async (ctx, api) => {  
+	console.log(ctx.attempt);  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| throwError(error) | Immediately throws an error |  
+| breakRetry(error) | Stops retry loop immediately |  
+| abort(error) | Aborts current request |  
+  
+---  
+  
+### after  
+  
+Runs after successful task execution.  
+  
+```ts  
+.after(async (ctx, api) => {  
+	api.setResult({  
+		wrapped: ctx.result  
+	});  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| setResult(value) | Replaces current result |  
+| throwError(error) | Throws an error |  
+| breakRetry(error) | Stops retry loop |  
+  
+---  
+  
+### result  
+  
+Runs before returning final result.  
+  
+```ts  
+.result(async (ctx, api) => {  
+	api.setResult(transform(ctx.result));  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| setResult(value) | Replaces current result |  
+| throwError(error) | Throws an error |  
+  
+---  
+  
+### retryIf  
+  
+Controls retry continuation.  
+  
+```ts  
+.retryIf(async (ctx, api) => {  
+	if (ctx.error instanceof TypeError) {  
+		api.proceedRetry();  
+	}  
+	else {  
+		api.cancelRetry();  
+	}  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| proceedRetry() | Continues retry |  
+| cancelRetry() | Cancels retry |  
+  
+---  
+  
+### onRetry  
+  
+Runs before retry delay.  
+  
+```ts  
+.onRetry(async (ctx, api) => {  
+	api.setDelay(5000);  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| throwError(error) | Throws an error |  
+| setDelay(ms) | Overrides retry delay |  
+| setAttempt(num) | Overrides attempt count |  
+  
+---  
+  
+### onError  
+  
+Runs after retry exhaustion.  
+  
+```ts  
+.onError(async (ctx, api) => {  
+	console.error(ctx.error);  
+	api.restart();  
+})  
+```  
+  
+#### Available APIs  
+  
+| API | Description |  
+|---|---|  
+| setResult(value) | Returns fallback value |  
+| throwError(error) | Throws an error |  
+| restart() | Restarts retry pipeline |  
+  
 ---
 
+## vigor.parse
+
+### Methods
+
+| Method | Description |
+|---|---|
+| target(response) | Sets target Response object |
+| settings(fn \| config) | Configures parser settings |
+| strategies(fn) | Configures parser strategies |
+| parsers(fn \| config) | Registers custom parsers |
+| interceptors(fn \| config) | Configures parser interceptors |
+| request(config?) | Executes parse pipeline |
 
-# 📡 vigor.fetch(origin)
+---
 
-vigor.fetch(origin: string)
+### target
 
-## Chain Methods
+Sets the target `Response`.
 
-| Method | Type | Description |
-|--------|------|-------------|
-| origin | (string) => VigorFetch | Set base URL |
-| path | (...string[]) => VigorFetch | Append URL path segments |
-| query | (object) => VigorFetch | Set query parameters |
-| method | (VigorFetchMethods) => VigorFetch | Set HTTP method |
-| headers | (HeadersInit) => VigorFetch | Set request headers |
-| body | (any) => VigorFetch | Set request body |
-| options | (object) => VigorFetch | Merge fetch options |
-| setting | (fn: (s: VigorFetchSettings) => VigorFetchSettings) => VigorFetch | Settings pipeline |
-| retryConfig | (fn: (r: VigorRetry) => VigorRetry) => VigorFetch | Retry engine config |
-| parseConfig | (fn: (p: VigorParse) => VigorParse) => VigorFetch | Response parser config |
-| interceptors | (fn: (i: VigorFetchInterceptors) => VigorFetchInterceptors) => VigorFetch | Lifecycle hooks |
-| request | () => Promise<T> | Execute request |
+```ts
+const response = await fetch("/api");
 
+await vigor
+  .parse(response)
+  .request();
+```
 
 ---
 
+### settings
+
+Configures parser behavior.
 
-## ⚙️ fetch().setting(s => s)
+```ts
+.settings(s =>
+  s
+    .original(false)
+    .fallback(null)
+)
+```
 
-| Field | Type | Description |
-|------|------|-------------|
-| origin | string | Base URL |
-| path | string[] | URL segments |
-| query | object | Query params |
-| unretry | number[] | Non-retry status codes |
-| retryHeaders | string[] | Retry-related headers |
-| method | string | HTTP method |
-| headers | object | Request headers |
-| body | any | Request body |
-| options | object | Fetch options |
-| default | T | Fallback value |
+#### Settings API
 
+| Method | Description | Default |
+|---|---|---|
+| original(boolean) | Returns original Response object | `false` |
+| fallback(value) | Fallback return value on parse failure | `throws` |
 
 ---
 
+### strategies
 
-## 🧩 fetch().interceptors(i => i)
+Configures parser strategy.
 
-| Hook | Signature | Description |
-|------|----------|-------------|
-| before | (ctx, { setOptions, throwError }) => void | Before request |
-| after | (ctx, { throwError }) => void | After success |
-| onError | (ctx, { setResult, throwError }) => void | Error handler |
-| result | (ctx, { setResult, throwError }) => void | Final result hook |
+```ts
+.strategies(s =>
+  s.contentType()
+)
+```
+
+---
+
+## Parse Strategies
+
+### contentType
+
+Parses response using `content-type` header.
 
+```ts
+.strategies(s =>
+  s.contentType()
+)
+```
+
+Supported:
+
+- JSON
+- Text
+- Blob
+- FormData
+- ArrayBuffer
+- Audio
+- Video
+- Image
 
 ---
 
+### sniff
 
-# 🔁 vigor.retry(task)
+Attempts all parsers until one succeeds.
 
-vigor.retry(task: VigorRetryTask<T>)
+```ts
+.strategies(s =>
+  s.sniff()
+)
+```
 
-## Methods
+Useful when:
 
-| Method | Type | Description |
-|--------|------|-------------|
-| target | (fn: VigorRetryTask<T>) => VigorRetry | Set retry function |
-| setting | (fn: (s: VigorRetrySettings) => VigorRetrySettings) => VigorRetry | Retry settings |
-| backoff | (fn: (b: VigorRetryBackoff) => VigorRetryBackoff) => VigorRetry | Backoff strategy |
-| interceptors | (fn: (i: VigorRetryInterceptors) => VigorRetryInterceptors) => VigorRetry | Lifecycle hooks |
-| request | () => Promise<T> | Execute retry flow |
-| createController | () => (error: Error) => void | Abort controller |
+- content-type is invalid
+- server responses are inconsistent
+- APIs return malformed headers
 
+---
+
+### custom
+
+Uses custom parser strategy.
+
+```ts
+.strategies(s =>
+  s.custom()
+    .func(async ({ response, parsers }) => {
+      return await parsers.json();
+    })
+)
+```
+
+#### API
+
+| Method | Description |
+|---|---|
+| func(fn) | Custom parse resolver |
 
 ---
 
+### parsers
 
-## ⚙️ retry().setting(s => s)
+Registers custom parsers.
+
+```ts
+.parsers(p =>
+  p.add("csv", async response => {
+    return parseCSV(await response.text());
+  })
+)
+```
 
-| Field | Type | Description |
-|------|------|-------------|
-| count | number | Max retry attempts |
-| limit | number | Timeout per attempt |
-| maxDelay | number | Max delay cap |
-| default | T | Fallback value |
+#### Parser API
 
+| Method | Description |
+|---|---|
+| add(name, parser) | Adds custom parser |
+| remove(name) | Removes parser |
+| clear() | Removes all parsers |
 
 ---
 
+### request
 
-## 📈 retry().backoff(b => b)
+Executes parse workflow.
 
-| Field | Type | Description |
-|------|------|-------------|
-| initialDelay | number | Initial delay |
-| baseDelay | number | Base delay |
-| factor | number | Exponential multiplier |
-| jitter | number | Random noise |
+```ts
+const result = await vigor
+  .parse(response)
+  .request();
+```
+
+---
 
+## Interceptors
+
+| Name | API |
+|---|:---:|
+| before | throwError |
+| after | setResult / throwError |
+| result | setResult / throwError |
+| onError | setResult / throwError |
 
 ---
 
+### before
+
+Runs before parsing starts.
 
-## 🧩 retry().interceptors(i => i)
+```ts
+.before(async (ctx, api) => {
+  console.log(ctx.response.headers);
+})
+```
 
-| Hook | Signature | Description |
-|------|----------|-------------|
-| before | (ctx, { setAttempt, throwError, abort }) => void | Before execution |
-| after | (ctx, { setAttempt, setResult, throwError }) => void | After success |
-| onError | (ctx, { setResult, throwError }) => void | Error handling |
-| onRetry | (ctx, { setDelay }) => void | Retry event |
-| retryIf | (ctx, { proceedRetry, cancelRetry }) => void | Retry decision |
+#### Available APIs
 
+| API | Description |
+|---|---|
+| throwError(error) | Immediately throws error |
 
 ---
 
+### after
+
+Runs after parser succeeds.
+
+```ts
+.after(async (ctx, api) => {
+  api.setResult({
+    wrapped: ctx.result
+  });
+})
+```
 
-# ⚡ vigor.all(tasks)
+#### Available APIs
 
-vigor.all(tasks: VigorAllTask<T>[])
+| API | Description |
+|---|---|
+| setResult(value) | Replaces parsed result |
+| throwError(error) | Throws error |
 
-## Methods
+---
 
-| Method | Type | Description |
-|--------|------|-------------|
-| target | (...tasks) => VigorAll | Set tasks |
-| setting | (fn: (s: VigorAllSettings) => VigorAllSettings) => VigorAll | Concurrency config |
-| interceptors | (fn: (i: VigorAllInterceptors) => VigorAllInterceptors) => VigorAll | Hooks |
-| request | () => Promise<Array<T | Error>> | Execute all tasks |
+### result
 
+Runs before returning final result.
+
+```ts
+.result(async (ctx, api) => {
+  api.setResult(transform(ctx.result));
+})
+```
+
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResult(value) | Replaces final result |
+| throwError(error) | Throws error |
 
 ---
 
+### onError
 
-## ⚙️ all().setting(s => s)
+Runs when parsing fails.
 
-| Field | Type | Description |
-|------|------|-------------|
-| concurrency | number | Max parallel tasks |
-| jitter | number | Delay randomness |
-| onlySuccess | boolean | Filters Success |
+```ts
+.onError(async (ctx, api) => {
+  api.setResult(null);
+})
+```
 
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResult(value) | Returns fallback value |
+| throwError(error) | Throws error |
 
 ---
 
+## Example
+
+```ts
+const response = await fetch("/api");
+
+const data = await vigor
+  .parse(response)
+  .strategies(s =>
+    s.sniff()
+  )
+  .interceptors(i =>
+    i.onError((ctx, api) => {
+      console.log(ctx.error);
+
+      api.setResult(null);
+    })
+  )
+  .request();
+```
 
-## 🧩 all().interceptors(i => i)
+## vigor.fetch
 
-| Hook | Signature | Description |
-|------|----------|-------------|
-| before | (ctx) => void | Before each task |
-| after | (ctx, { setResult }) => void | After success |
-| onError | (ctx, { setResult }) => void | Error handling |
-| result | (ctx, { setResult }) => void | Final aggregation |
+### Methods
 
+| Method | Description |
+|---|---|
+| origin(...paths) | Sets base URL and origin paths |
+| path(...paths) | Appends request paths |
+| query(params) | Sets query parameters |
+| headers(headers) | Sets request headers |
+| options(options) | Sets fetch options |
+| retryConfig(fn \| config) | Configures retry engine |
+| parseConfig(fn \| config) | Configures parse engine |
+| interceptors(fn \| config) | Configures fetch interceptors |
+| abortSignals(...signals) | Attaches external AbortSignals |
+| request(config?) | Executes fetch pipeline |
 
 ---
 
+### origin
 
-# 🧪 vigor.parse(response)
+Sets base URL and origin paths.
 
-vigor.parse(response: Response)
+```ts
+.fetch("https://api.example.com/", "/api")
+```
 
-| Method | Type | Description |
-|--------|------|-------------|
-| target | Response | Set response |
-| original | boolean | Return raw response |
-| type | keyof Response | Force parse type |
-| request | () => Promise<T> | Execute parsing |
+Produces:
 
+```txt
+https://api.example.com/api
+```
 
 ---
 
+### path
 
-# 🚀 vigor.fetch examples
+Appends request paths.
 
-## GET request
 ```ts
-vigor.fetch("https://api.example.com")
-  .path("users", "profile")
-  .query({ id: 123 })
-  .method("GET")
-  .request()
+.path("v1", "users")
+```
+
+Produces:
+
+```txt
+https://api.example.com/api/v1/users
 ```
+
 ---
 
-## POST request
+### query
+
+Adds query parameters.
+
 ```ts
-vigor.fetch("https://api.example.com")
-  .path("users")
-  .method("POST")
-  .headers({
-    Authorization: "Bearer TOKEN"
-  })
-  .body({
-    name: "John",
-    age: 30
-  })
-  .request()
+.query({
+  page: 1,
+  limit: 10
+})
+```
+
+Produces:
+
+```txt
+?page=1&limit=10
 ```
+
 ---
 
-## fetch + retry + backoff + parse
+### headers
+
+Sets request headers.
+
 ```ts
-vigor.fetch("https://api.example.com")
-  .path("data")
-  .retryConfig(r =>
-    r
-      .setting(s =>
-        s
-          .count(3)
-          .limit(5000)
-      )
-      .backoff(b =>
-        b
-          .factor(2)
-          .jitter(300)
-      )
-  )
-  .parseConfig(p =>
-    p.original(false)
-  )
-  .request()
+.headers({
+  Authorization: "Bearer token"
+})
 ```
+
 ---
 
-# 🔁 vigor.retry examples
+### options
+
+Sets native fetch options.
 
-## basic retry
 ```ts
-vigor.retry(async (ctx, { signal }) => {
-  const res = await fetch("https://api.example.com/data", { signal })
-  if (!res.ok) throw new Error("failed")
-  return res.json()
+.options({
+  method: "POST",
+  body: JSON.stringify({
+    username: "john"
+  })
 })
-.setting(s =>
-  s
-    .count(5)
-    .limit(3000)
+```
+
+---
+
+### retryConfig
+
+Configures internal retry engine.
+
+```ts
+.retryConfig(r => r
+	.settings(s => s
+		.attempt(5)
+  )
 )
-.backoff(b =>
-  b
-    .baseDelay(500)
-    .factor(2)
+```
+
+---
+
+### parseConfig
+
+Configures internal parse engine.
+
+```ts
+.parseConfig(p => p
+	.strategies(s => s
+		.sniff()
+  )
 )
-.request()
 ```
 
+---
+
+### abortSignals
+
+Attaches external AbortSignals.
+
+```ts
+const controller = new AbortController();
+
+await vigor
+  .fetch("/api")
+  .abortSignals(controller.signal)
+  .request();
+```
 
 ---
 
+### request
+
+Executes fetch workflow.
 
-## retryIf control
 ```ts
-vigor.retry(async () => {
-  const res = await fetch("https://api.example.com")
-  return res.json()
+const data = await vigor
+  .fetch("https://api.example.com")
+  .request();
+```
+
+---
+
+## Interceptors
+
+| Name | API |
+|---|:---:|
+| before | throwError / abort |
+| after | setResponse / throwError |
+| result | setResult / throwError |
+| onError | setResult / throwError / retry |
+
+---
+
+### before
+
+Runs before fetch execution.
+
+```ts
+.before(async (ctx, api) => {
+  console.log(ctx.url);
 })
-.interceptors(i =>
-  i.retryIf((ctx, { cancelRetry }) => {
-    const result = ctx.runtime.result
+```
 
-    if (result?.error === "fatal") {
-      cancelRetry()
-    }
-  })
-)
-.request()
+#### Available APIs
+
+| API | Description |
+|---|---|
+| throwError(error) | Immediately throws error |
+| abort(error) | Aborts request |
+
+---
+
+### after
+
+Runs after receiving Response.
+
+```ts
+.after(async (ctx, api) => {
+  console.log(ctx.response.status);
+})
 ```
 
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResponse(response) | Replaces Response object |
+| throwError(error) | Throws error |
 
 ---
 
+### result
+
+Runs before returning parsed result.
 
-## abort controller
 ```ts
-const retry = vigor.retry(async (ctx, { signal }) => {
-  const res = await fetch("https://api.example.com", { signal })
-  return res.json()
+.result(async (ctx, api) => {
+  api.setResult({
+    data: ctx.result
+  });
 })
+```
+
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResult(value) | Replaces final result |
+| throwError(error) | Throws error |
+
+---
 
-const abort = retry.createController()
+### onError
 
-setTimeout(() => {
-  abort(new Error("manual abort"))
-}, 2000)
+Runs when fetch fails.
 
-await retry.request()
+```ts
+.onError(async (ctx, api) => {
+  api.retry();
+})
 ```
 
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResult(value) | Returns fallback value |
+| throwError(error) | Throws error |
+| retry() | Re-executes fetch pipeline |
 
 ---
 
+## Example
 
-# ⚡ vigor.all examples
 ```ts
-vigor.all([
-  async () => fetch("https://api.com/a").then(r => r.json()),
-  async () => fetch("https://api.com/b").then(r => r.json()),
-  async () => fetch("https://api.com/c").then(r => r.json())
-]).request()
+const data = await vigor
+  .fetch("https://api.example.com", "api")
+  .path("v1", "users")
+  .query({
+    page: 1
+  })
+  .headers({
+    Authorization: "Bearer token"
+  })
+  .retryConfig(r =>
+    r.settings(s =>
+      s.attempt(5)
+    )
+  )
+  .request();
 ```
 
+## vigor.all
+
+### Methods
+
+| Method | Description |
+|---|---|
+| target(...tasks) | Sets async task list |
+| settings(fn \| config) | Configures concurrency settings |
+| interceptors(fn \| config) | Configures concurrency interceptors |
+| abortSignals(...signals) | Attaches external AbortSignals |
+| request(config?) | Executes concurrency pipeline |
 
 ---
 
+### target
+
+Sets async task list.
 
 ```ts
-vigor.all([
-  async () => "A",
-  async () => "B",
-  async () => "C",
-  async () => "D"
-])
-.setting(s =>
-  s
+.all(
+  async () => fetch("/api/1"),
+  async () => fetch("/api/2")
+)
+```
+
+---
+
+### settings
+
+Configures concurrency behavior.
+
+```ts
+.settings(s => s
     .concurrency(2)
-    .jitter(500)
+    .onlySuccess(true)
 )
-.request()
 ```
 
+#### Settings API
+
+| Method | Description | Default |
+|---|---|---|
+| concurrency(number) | Maximum concurrent tasks | `Infinity` |
+| onlySuccess(boolean) | Returns only successful results | `false` |
+| fallback(value) | Fallback return value | `throws` |
 
 ---
 
+### abortSignals
+
+Attaches external AbortSignals.
 
 ```ts
-vigor.all([
-  async () => "ok1",
-  async () => { throw new Error("fail") },
-  async () => "ok2"
-]).request()
+const controller = new AbortController();
+
+await vigor
+  .all(task1, task2)
+  .abortSignals(controller.signal)
+  .request();
 ```
 
 ---
 
+### request
 
-# 🧪 vigor.parse examples
-```ts
-const res = await fetch("https://api.com/data")
+Executes concurrency workflow.
 
-vigor.parse(res).request()
+```ts
+const results = await vigor
+  .all(task1, task2)
+  .request();
 ```
 
+---
+
+## Interceptors
+
+| Name | API |
+|---|:---:|
+| before | throwError / abort |
+| afterEach | setResult / throwError |
+| after | setResults / throwError |
+| result | setResults / throwError |
+| onError | setResults / throwError |
 
 ---
 
+### before
+
+Runs before task execution starts.
 
 ```ts
-const img = await fetch("https://api.com/image.png")
+.before(async (ctx, api) => {
+  console.log(ctx.tasks.length);
+})
+```
+
+#### Available APIs
+
+| API | Description |
+|---|---|
+| throwError(error) | Immediately throws error |
+| abort(error) | Aborts execution |
+
+---
+
+### afterEach
+
+Runs after each task resolves.
 
-vigor.parse(img)
-  .type("blob")
-  .request()
+```ts
+.afterEach(async (ctx, api) => {
+  console.log(ctx.result);
+})
 ```
 
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResult(value) | Replaces task result |
+| throwError(error) | Throws error |
 
 ---
 
+### after
+
+Runs after all tasks complete.
 
 ```ts
-const raw = await fetch("https://api.com")
+.after(async (ctx, api) => {
+  console.log(ctx.results);
+})
+```
+
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResults(value) | Replaces result array |
+| throwError(error) | Throws error |
 
-vigor.parse(raw)
-  .original(true)
-  .request()
+---
+
+### result
+
+Runs before returning final results.
+
+```ts
+.result(async (ctx, api) => {
+  api.setResults(
+    ctx.results.filter(Boolean)
+  );
+})
 ```
 
+#### Available APIs
+
+| API | Description |
+|---|---|
+| setResults(value) | Replaces final results |
+| throwError(error) | Throws error |
 
 ---
 
+### onError
+
+Runs when concurrency execution fails.
 
-# 🔥 full pipeline example
 ```ts
-vigor.fetch("https://api.example.com")
-  .path("users")
-  .query({ page: 1 })
-  .method("GET")
-  .retryConfig(r =>
-    r
-      .setting(s =>
-        s
-          .count(3)
-          .limit(5000)
-      )
-      .backoff(b =>
-        b
-          .factor(2)
-          .jitter(200)
-      )
-      .interceptors(i =>
-        i.onRetry((ctx, { setDelay }) => {
-          setDelay(1000)
-        })
-      )
-  )
-  .parseConfig(p =>
-    p.original(false)
-  )
-  .interceptors(i =>
-    i.result(() => {
-      console.log("done")
-    })
-  )
-  .request()
+.onError(async (ctx, api) => {
+  api.setResults([]);
+})
 ```
 
+#### Available APIs
 
----
+| API | Description |
+|---|---|
+| setResults(value) | Returns fallback results |
+| throwError(error) | Throws error |
+
+---
+
+## Example
+
+```ts
+const results = await vigor
+  .all(
+    async () => fetch("/api/1"),
+    async () => fetch("/api/2"),
+    async () => fetch("/api/3")
+  )
+  .settings(s =>
+    s
+      .concurrency(2)
+      .onlySuccess(true)
+  )
+  .request();
+```