vigor-fetch 2.1.0 → 2.2.0

package/dist/index.js

@@ -2,158 +2,144 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const VIGOR_ERROR_MESSAGES = {
+    TIMEOUT: ({ limit, attempt }) => `Timeout: exceeded ${limit}ms (attempt: ${attempt})`,
+    EXHAUSTED: ({ maxAttempts }) => `Retry exhausted: max ${maxAttempts})`,
+    INVALID_URL: ({ received }) => `Invalid URL: ${received}`,
+    INVALID_PROTOCOL: ({ expected, received }) => `Invalid protocol: ${received} (expected ${expected.join(", ")})`,
+    FETCH_ERROR: ({ status, statusText, url }) => `HTTP Error: ${status} ${statusText} (url: ${url})`,
+    PARSE_FAILED: ({ expected }) => `Parse failed: expected ${expected}`,
+    INVALID_TYPE: ({ expected, received }) => `Invalid parser type: ${expected}`,
+    TARGET_MISSING: () => `Target missing`,
+    REQUEST_FAILED: ({ index, error }) => `Request failed at index ${index}: ${error.message}`,
+    UNKNOWN: () => `Unknown error`
+};
 class VigorError extends Error {
-    timestamp;
+    timestamp = new Date();
     method;
+    code;
     cause;
     context;
     type;
     data;
-    constructor(message, options) {
+    constructor(code, options) {
+        const messageFn = VIGOR_ERROR_MESSAGES[code];
+        const message = `[${code}] ${messageFn(options?.data)}`;
         super(message, { cause: options?.cause });
         this.name = new.target.name;
-        this.timestamp = new Date();
-        if (options?.method !== undefined)
-            this.method = options.method;
-        if (options?.context !== undefined)
-            this.context = options.context;
-        if (options?.type !== undefined)
-            this.type = options.type;
-        if (options?.data !== undefined)
-            this.data = options.data;
+        this.method = options?.method;
+        this.code = code;
+        this.context = options?.context;
+        this.type = options?.type;
+        this.data = options.data;
         Object.setPrototypeOf(this, new.target.prototype);
         Error.captureStackTrace?.(this, new.target);
     }
 }
 class VigorRetryError extends VigorError {
-    constructor(message, options) {
-        super(message, options);
+    constructor(code, options) {
+        super(code, options);
     }
 }
 class VigorParseError extends VigorError {
-    constructor(message, options) {
-        super(message, options);
+    constructor(code, options) {
+        super(code, options);
     }
 }
 class VigorFetchError extends VigorError {
-    constructor(message, options) {
-        super(message, options);
+    constructor(code, options) {
+        super(code, options);
     }
 }
 class VigorAllError extends VigorError {
-    constructor(message, options) {
-        super(message, options);
+    constructor(code, options) {
+        super(code, options);
     }
 }
+const EMPTY = Symbol("EMPTY");
 class VigorStatus {
+    _base;
     _config;
-    _ctor;
-    _errorCtor;
-    constructor(_config, _ctor, _errorCtor) {
-        this._config = _config;
-        this._ctor = _ctor;
-        this._errorCtor = _errorCtor;
-    }
-    _create(config) { return this._ctor(config); }
-    _next(config) { return this._create({ ...this._config, ...config }); }
+    constructor(config, _base) {
+        this._base = _base;
+        this._config = { ...this._base, ...config };
+    }
     getConfig() { return this._config; }
-    _pipeSub(value, Ctor, fn, errorKey) {
-        const ErrorCtor = this._errorCtor?.();
-        if (typeof fn !== "function" && ErrorCtor) {
-            throw new ErrorCtor("ctor expects function", {
-                method: errorKey,
-                type: "invalid_input",
-                data: { expected: "function", received: fn }
-            });
-        }
-        return fn(new Ctor(value)).getConfig();
+    getBase() { return this._base; }
+    _next(config) { return new this.constructor({ ...this._config, ...config }, this._base); }
+    _pipsub(config, fn, ctor) {
+        return fn(new ctor(config)).getConfig();
     }
 }
 class VigorRetrySettings extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             count: 5,
             limit: 10000,
             maxDelay: 10000,
-        };
-        super({ ...base, ...config }, (c) => new VigorRetrySettings(c));
-        this._base = base;
+            default: EMPTY
+        });
     }
-    getBase() { return this._base; }
     count(num) { return this._next({ count: num }); }
     limit(num) { return this._next({ limit: num }); }
     maxDelay(num) { return this._next({ maxDelay: num }); }
     default(obj) { return this._next({ default: obj }); }
 }
 class VigorRetryBackoff extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             initialDelay: 0,
             baseDelay: 1000,
             factor: 1.7,
             jitter: 1000
-        };
-        super({ ...base, ...config }, (c) => new VigorRetryBackoff(c));
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
     initialDelay(num) { return this._next({ initialDelay: num }); }
     baseDelay(num) { return this._next({ baseDelay: num }); }
     factor(num) { return this._next({ factor: num }); }
     jitter(num) { return this._next({ jitter: num }); }
+    static randomJitter(num) { return Math.random() * num; }
 }
 class VigorRetryInterceptors extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             before: [],
             after: [],
             onError: [],
             onRetry: [],
             retryIf: []
-        };
-        super({ ...base, ...config }, (c) => new VigorRetryInterceptors(c));
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
-    before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
-    after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
-    onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
-    onRetry(...funcs) { return this._next({ onRetry: [...this.getConfig().onRetry, ...funcs.flat()] }); }
-    retryIf(...funcs) { return this._next({ retryIf: [...this.getConfig().retryIf, ...funcs.flat()] }); }
+    before(...funcs) { return this._next({ ...this._config, before: [...this._config.before, ...funcs.flat()] }); }
+    after(...funcs) { return this._next({ ...this._config, after: [...this._config.after, ...funcs.flat()] }); }
+    onError(...funcs) { return this._next({ ...this._config, onError: [...this._config.onError, ...funcs.flat()] }); }
+    onRetry(...funcs) { return this._next({ ...this._config, onRetry: [...this._config.onRetry, ...funcs.flat()] }); }
+    retryIf(...funcs) { return this._next({ ...this._config, retryIf: [...this._config.retryIf, ...funcs.flat()] }); }
 }
 class VigorRetry extends VigorStatus {
-    _base;
-    _controller = new AbortController();
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             target: null,
             setting: new VigorRetrySettings().getBase(),
             backoff: new VigorRetryBackoff().getBase(),
-            interceptors: new VigorRetryInterceptors().getBase()
-        };
-        super({ ...base, ...config }, (c) => new VigorRetry(c), () => VigorRetryError);
-        this._base = base;
+            interceptors: new VigorRetryInterceptors().getBase(),
+            controller: config.controller || new AbortController()
+        });
     }
-    getBase() { return this._base; }
-    target(func) { return new VigorRetry({ ...this._config, target: func, setting: this._config.setting, interceptors: this._config.interceptors }); }
-    createController() { const controller = new AbortController(); this._controller = controller; return (error) => controller.abort(error); }
+    _transfer(config) { return new VigorRetry({ ...this._config, ...config }); }
+    _calculateDelay(initialDelay, baseDelay, factor, attempt, jitter, maxDelay) {
+        return Math.max(0, Math.min(maxDelay, initialDelay + baseDelay * Math.pow(factor, attempt) + VigorRetryBackoff.randomJitter(jitter)));
+    }
+    createController() { return this._config.controller = new AbortController(); }
+    target(func) { return this._transfer({ target: func }); }
     setting(func) {
-        return this._next({
-            setting: this._pipeSub(this._config.setting, VigorRetrySettings, func, "setting")
-        });
+        return this._next({ setting: this._pipsub(this._config.setting, func, VigorRetrySettings) });
     }
     backoff(func) {
-        return this._next({
-            backoff: this._pipeSub(this._config.backoff, VigorRetryBackoff, func, "backoff")
-        });
+        return this._next({ backoff: this._pipsub(this._config.backoff, func, VigorRetryBackoff) });
     }
     interceptors(func) {
-        return this._next({
-            interceptors: this._pipeSub(this._config.interceptors, VigorRetryInterceptors, func, "interceptors")
-        });
+        return this._next({ interceptors: this._pipsub(this._config.interceptors, func, VigorRetryInterceptors) });
     }
     async request() {
         const config = this._config;
@@ -168,8 +154,9 @@ class VigorRetry extends VigorStatus {
                 retryIf: [...config.interceptors.retryIf],
             },
             backoff: { ...config.backoff },
+            controller: config.controller,
             runtime: {
-                result: null,
+                result: EMPTY,
                 controller: null,
                 attempt: 0,
                 aborted: false,
@@ -187,7 +174,6 @@ class VigorRetry extends VigorStatus {
         };
         try {
             while (ctx.runtime.attempt < ctx.setting.count) {
-                ctx.runtime.attempt++;
                 ctx.runtime.controller = new AbortController();
                 let listener;
                 let timerId;
@@ -197,7 +183,7 @@ class VigorRetry extends VigorStatus {
                 } };
                 try {
                     ctx.runtime.signal = AbortSignal.any([
-                        this._controller.signal,
+                        ctx.controller.signal,
                         ctx.runtime.controller.signal
                     ]);
                     ctx.runtime.abortPromise = new Promise((_, reject) => {
@@ -211,7 +197,14 @@ class VigorRetry extends VigorStatus {
                         timerId = setTimeout(() => {
                             if (ctx.runtime.aborted)
                                 return;
-                            abort(new VigorRetryError(`timeouted after ${ctx.setting.limit}`, { method: "request", type: "timeout", data: { limit: ctx.setting.limit, attempt: ctx.runtime.attempt } }));
+                            abort(new VigorRetryError("TIMEOUT", {
+                                method: "request",
+                                type: "timeout",
+                                data: {
+                                    limit: ctx.setting.limit,
+                                    attempt: ctx.runtime.attempt
+                                }
+                            }));
                         }, ctx.setting.limit);
                     });
                     for (const func of ctx.interceptors.before) {
@@ -244,7 +237,8 @@ class VigorRetry extends VigorStatus {
                     if (!ctx.runtime.retry) {
                         throw ctx.runtime.error;
                     }
-                    ctx.runtime.delay = Math.min(ctx.setting.maxDelay, Math.max(0, ctx.backoff.initialDelay + ctx.backoff.baseDelay * Math.pow(ctx.backoff.factor, ctx.runtime.attempt - 1))) + calculateJitter(ctx.backoff.jitter);
+                    const { initialDelay, baseDelay, factor, jitter } = ctx.backoff;
+                    ctx.runtime.delay = this._calculateDelay(initialDelay, baseDelay, factor, ctx.runtime.attempt, jitter, ctx.setting.maxDelay);
                     const setDelay = (delay) => ctx.runtime.delay = delay;
                     for (const func of ctx.interceptors.onRetry) {
                         await func(ctx, { setAttempt, throwError, setDelay });
@@ -253,11 +247,11 @@ class VigorRetry extends VigorStatus {
                         const timer = setTimeout(resolve, ctx.runtime.delay);
                         const abortHandler = () => {
                             clearTimeout(timer);
-                            reject(this._controller.signal.reason);
+                            reject(ctx.controller.signal.reason);
                         };
-                        if (this._controller.signal.aborted)
+                        if (ctx.controller.signal.aborted)
                             return abortHandler();
-                        this._controller.signal.addEventListener("abort", abortHandler, { once: true });
+                        ctx.controller.signal.addEventListener("abort", abortHandler, { once: true });
                     });
                 }
                 finally {
@@ -265,8 +259,15 @@ class VigorRetry extends VigorStatus {
                     if (listener)
                         ctx.runtime.signal.removeEventListener("abort", listener);
                 }
+                ctx.runtime.attempt++;
             }
-            throw new VigorRetryError(`Maximum retry attempts (${ctx.setting.count}) reached. Task failed or timed out.`, { method: "request", type: "exhausted", data: { limit: ctx.setting.limit, attempt: ctx.runtime.attempt, maxAttempts: ctx.setting.count } });
+            throw new VigorRetryError("EXHAUSTED", {
+                method: "request",
+                type: "retry",
+                data: {
+                    maxAttempts: ctx.setting.count,
+                }
+            });
         }
         catch (error) {
             ctx.runtime.error = error;
@@ -275,45 +276,44 @@ class VigorRetry extends VigorStatus {
             for (const func of ctx.interceptors.onError) {
                 await func(ctx, { setResult, throwError });
             }
-            if (overrided && ctx.runtime.result !== undefined)
+            if (overrided && ctx.runtime.result !== EMPTY)
                 return ctx.runtime.result;
-            if (ctx.setting.default !== undefined)
+            if (ctx.setting.default !== EMPTY)
                 return ctx.setting.default;
             throw error;
         }
     }
 }
-const basic = { key: /text/, parse: (res) => res.text(), type: "text" };
-const parser = [
-    { key: /json/, parse: (res) => res.json(), type: "json" },
-    { key: /multipart\/form-data/, parse: (res) => res.formData(), type: "formData" },
-    { key: /octet-stream/, parse: (res) => res.arrayBuffer(), type: "arrayBuffer" },
-    { key: /(image|video|audio|pdf)/, parse: (res) => res.blob(), type: "blob" },
-    basic
-];
-const supported = parser.map(i => i.type);
 class VigorParse extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             original: false
-        };
-        super({ ...base, ...config }, (c) => new VigorParse(c));
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
-    target(response) { return this._next({ target: response }); }
-    original(bool) { return this._next({ original: bool }); }
-    type(str) { return this._next({ type: str }); }
+    static stategy = [
+        { key: /text/, parse: (res) => res.text(), type: "text" },
+        { key: /json/, parse: (res) => res.json(), type: "json" },
+        { key: /multipart\/form-data/, parse: (res) => res.formData(), type: "formData" },
+        { key: /octet-stream/, parse: (res) => res.arrayBuffer(), type: "arrayBuffer" },
+        { key: /(image|video|audio|pdf)/, parse: (res) => res.blob(), type: "blob" },
+    ];
+    static supported = this.stategy.map(i => i.type);
+    _transfer(config) { return new VigorParse({ ...this._config, ...config }); }
+    target(res) { return this._next({ target: res }); }
+    original(bool) { return this._transfer({ ...this._config, original: bool }); }
+    type(type) { return this._transfer({ ...this._config, result: undefined, type }); }
     async request() {
         const config = this._config;
-        if (!config.target)
-            throw new VigorParseError("target is required", { method: "request", type: "invalid_target", data: {
-                    expected: "Response",
-                    received: config.target,
-                } });
-        if (config.original)
+        if (!(config.target instanceof Response)) {
+            throw new VigorParseError("TARGET_MISSING", {
+                method: "request",
+                type: "args_missing",
+                data: undefined
+            });
+        }
+        if (config.original) {
             return config.target;
+        }
         const contentType = config.target.headers.get("Content-Type") || "";
         let strategy;
         try {
@@ -321,44 +321,42 @@ class VigorParse extends VigorStatus {
                 strategy = { type: config.type };
                 const parser = config.target[config.type];
                 if (!parser || typeof parser !== 'function')
-                    throw new VigorParseError(`failed to parse: '${strategy?.type ?? "unknown"}'`, { method: "request", type: "invalid_type", data: {
-                            expected: config.type,
-                            supported: supported,
-                            response: config.target,
-                            headers: contentType,
-                        } });
+                    throw new VigorParseError("PARSE_FAILED", {
+                        method: "request",
+                        type: "parse_failed",
+                        data: {
+                            expected: strategy?.type ?? "unknown"
+                        }
+                    });
                 return await parser();
             }
-            strategy = parser.find(i => i.key.test(contentType)) ?? basic;
+            strategy = VigorParse.stategy.find(i => i.key.test(contentType)) ?? VigorParse.stategy[0];
             return await strategy.parse(config.target);
         }
         catch (error) {
             if (error instanceof VigorParseError)
                 throw error;
-            throw new VigorParseError(`failed to parse: '${strategy?.type ?? "unknown"}'`, { method: "request", type: "parse_failed", data: {
-                    expected: strategy?.type ?? "unknown",
-                    supported: supported,
-                    response: config.target,
-                    headers: contentType,
-                    error
-                } });
+            throw new VigorParseError("PARSE_FAILED", {
+                method: "request",
+                type: "parse_failed",
+                data: {
+                    expected: strategy?.type ?? "unknown"
+                }
+            });
         }
     }
 }
 class VigorFetchSettings extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             origin: "",
             path: [],
             query: {},
             unretry: [400, 401, 403, 404, 405, 413, 422],
             retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
-        };
-        super({ ...base, ...config }, (c) => new VigorFetchSettings(c));
-        this._base = base;
+            default: EMPTY
+        });
     }
-    getBase() { return this._base; }
     origin(str) { return this._next({ origin: str }); }
     path(...strs) { return this._next({ path: [...this._config.path, ...strs.flat()] }); }
     query(obj) { return this._next({ query: { ...this._config.query, ...obj } }); }
@@ -371,36 +369,28 @@ class VigorFetchSettings extends VigorStatus {
     default(obj) { return this._next({ default: obj }); }
 }
 class VigorFetchInterceptors extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             before: [],
             after: [],
             onError: [],
             result: []
-        };
-        super({ ...base, ...config }, (c) => new VigorFetchInterceptors(c));
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
     before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
     after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
     onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
     result(...funcs) { return this._next({ result: [...this.getConfig().result, ...funcs.flat()] }); }
 }
 class VigorFetch extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             setting: new VigorFetchSettings().getBase(),
             retryConfig: new VigorRetry().getBase(),
             parseConfig: new VigorParse().getBase(),
             interceptors: new VigorFetchInterceptors().getBase(),
-        };
-        super({ ...base, ...config }, (c) => new VigorFetch(c), () => VigorRetryError);
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
     origin(str) { return this._next({ setting: { ...this._config.setting, origin: str } }); }
     path(...strs) { return this._next({ setting: { ...this._config.setting, path: [...this._config.setting.path, ...strs.flat()] } }); }
     query(obj) { return this._next({ setting: { ...this._config.setting, query: { ...this._config.setting.query, ...obj } } }); }
@@ -409,63 +399,48 @@ class VigorFetch extends VigorStatus {
     body(obj) { return this._next({ setting: { ...this._config.setting, body: obj } }); }
     options(obj) { return this._next({ setting: { ...this._config.setting, options: obj } }); }
     setting(func) {
-        return this._next({
-            setting: this._pipeSub(this._config.setting, VigorFetchSettings, func, "setting")
-        });
+        return this._next({ setting: this._pipsub(this._config.setting, func, VigorFetchSettings) });
+    }
+    interceptors(func) {
+        return this._next({ interceptors: this._pipsub(this._config.interceptors, func, VigorFetchInterceptors) });
     }
     retryConfig(func) {
-        return this._next({
-            retryConfig: this._pipeSub(this._config.retryConfig, VigorRetry, func, "retryConfig")
-        });
+        return this._next({ retryConfig: this._pipsub(this._config.retryConfig, func, VigorRetry) });
     }
     parseConfig(func) {
-        return this._next({
-            parseConfig: this._pipeSub(this._config.parseConfig, VigorParse, func, "parseConfig")
-        });
+        return this._next({ parseConfig: this._pipsub(this._config.parseConfig, func, VigorParse) });
     }
     buildUrl(origin, path, query) {
         if (!origin)
-            throw new VigorFetchError("buildUrl expects 'origin'", {
-                type: "invalid_input", method: "buildUrl", data: {
-                    expected: "string", received: origin
+            throw new VigorFetchError("INVALID_URL", {
+                method: "buildUrl",
+                data: {
+                    received: origin
                 }
             });
-        try {
-            const url = new URL(origin);
-            if (path && path.length > 0) {
-                const cleanPath = path
-                    .filter(p => p && typeof p === 'string')
-                    .map(p => p.replace(/^\/+|\/+$/g, ''))
-                    .join('/');
-                if (cleanPath) {
-                    const base = url.pathname.endsWith('/') ? url.pathname : url.pathname + '/';
-                    url.pathname = base + cleanPath;
-                }
+        const url = new URL(origin);
+        const segments = [
+            url.pathname,
+            ...path
+        ]
+            .flat()
+            .filter(Boolean)
+            .flatMap(p => p.split('/'))
+            .filter(Boolean);
+        url.pathname = '/' + segments.join('/');
+        const params = new URLSearchParams(url.search);
+        for (const [k, v] of Object.entries(query ?? {})) {
+            if (v == null)
+                continue;
+            if (Array.isArray(v)) {
+                v.forEach(i => params.append(k, String(i)));
             }
-            if (query && typeof query === 'object') {
-                Object.entries(query).forEach(([key, value]) => {
-                    if (value === null || value === undefined)
-                        return;
-                    if (Array.isArray(value)) {
-                        value.forEach(v => url.searchParams.append(key, String(v)));
-                    }
-                    else {
-                        url.searchParams.set(key, String(value));
-                    }
-                });
+            else {
+                params.set(k, String(v));
             }
-            return url.toString();
-        }
-        catch (e) {
-            throw new VigorFetchError(`Invalid URL origin: ${origin}`, {
-                type: "invalid_url", method: "buildUrl", data: { error: e }
-            });
         }
-    }
-    interceptors(func) {
-        return this._next({
-            interceptors: this._pipeSub(this._config.interceptors, VigorFetchInterceptors, func, "interceptors")
-        });
+        url.search = params.toString();
+        return url.toString();
     }
     async request() {
         const config = this._config;
@@ -490,15 +465,21 @@ class VigorFetch extends VigorStatus {
                 onError: [...config.interceptors.onError],
                 result: [...config.interceptors.result]
             },
-            runtime: {}
+            runtime: {
+                result: EMPTY
+            }
         };
         const throwError = (error) => { throw error; };
         try {
             ctx.runtime.unretrySet = new Set(ctx.setting.unretry);
             if (!/^(https?|data|blob|file|about):\/\//.test(ctx.setting.origin))
-                throw new VigorFetchError(`Invalid Protocol`, { type: "Invalid Protocol", method: "request", data: {
-                        expected: ["http", "https", "data", "blob", "file", "about"], received: ctx.setting.origin
-                    } });
+                throw new VigorFetchError("INVALID_PROTOCOL", {
+                    method: "request",
+                    data: {
+                        expected: ["http", "https", "data", "blob", "file", "about"],
+                        received: ctx.setting.origin
+                    }
+                });
             ctx.runtime.url = this.buildUrl(config.setting.origin, config.setting.path, config.setting.query);
             const isJson = Array.isArray(ctx.setting.body) || (!!ctx.setting.body && Object.getPrototypeOf(ctx.setting.body) === Object.prototype);
             ctx.runtime.baseOptions = {
@@ -519,9 +500,14 @@ class VigorFetch extends VigorStatus {
             const checkOk = async (ctx2, { throwError }) => {
                 const result = ctx2.runtime.result;
                 if (!result.ok)
-                    return throwError?.(new VigorFetchError(`HTTP Error: ${result.status} ${result.statusText}`, {
-                        method: "request", type: "fetch_error",
-                        data: { status: result.status, statusText: result.statusText, url: result.url }
+                    return throwError?.(new VigorFetchError("FETCH_ERROR", {
+                        method: "request",
+                        type: "fetch_error",
+                        data: {
+                            status: result.status,
+                            statusText: result.statusText,
+                            url: result.url
+                        }
                     }));
             };
             const handleBlacklist = (ctx2, { cancelRetry }) => {
@@ -567,96 +553,95 @@ class VigorFetch extends VigorStatus {
             for (const func of ctx.interceptors.onError) {
                 await func(ctx, { setResult, throwError });
             }
-            if (overrided && ctx.runtime.result !== undefined)
+            if (overrided && ctx.runtime.result !== EMPTY)
                 return ctx.runtime.result;
-            if (ctx.setting.default !== undefined)
+            if (ctx.setting.default !== EMPTY)
                 return ctx.setting.default;
             throw error;
         }
     }
 }
 class VigorAllSettings extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             concurrency: 5,
-            jitter: 1000
-        };
-        super({ ...base, ...config }, (c) => new VigorAllSettings(c));
-        this._base = base;
+            jitter: 1000,
+            onlySuccess: false
+        });
     }
-    getBase() { return this._base; }
     concurrency(num) { return this._next({ concurrency: num }); }
     jitter(num) { return this._next({ jitter: num }); }
+    onlySuccess(bool) { return this._next({ onlySuccess: bool }); }
 }
 class VigorAllInterceptors extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             before: [],
             after: [],
             onError: [],
             result: []
-        };
-        super({ ...base, ...config }, (c) => new VigorAllInterceptors(c));
-        this._base = base;
+        });
     }
-    getBase() { return this._base; }
     before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
     after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
     onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
     result(...funcs) { return this._next({ result: [...this.getConfig().result, ...funcs.flat()] }); }
 }
 class VigorAll extends VigorStatus {
-    _base;
-    constructor(config) {
-        const base = {
+    constructor(config = {}) {
+        super(config, {
             target: [],
             setting: new VigorAllSettings().getBase(),
             interceptors: new VigorAllInterceptors().getBase()
-        };
-        super({ ...base, ...config }, (c) => new VigorAll(c), () => VigorAllError);
-        this._base = base;
+        });
+    }
+    _transfer(config) {
+        return new VigorAll({
+            ...this._config,
+            ...config
+        });
+    }
+    target(...funcs) {
+        return this._transfer({
+            target: funcs
+        });
     }
-    getBase() { return this._base; }
-    target(...funcs) { return this._next({ target: [...this._config.target, ...funcs.flat()] }); }
     setting(func) {
         return this._next({
-            setting: this._pipeSub(this._config.setting, VigorAllSettings, func, "setting")
+            setting: this._pipsub(this._config.setting, func, VigorAllSettings)
         });
     }
     interceptors(func) {
         return this._next({
-            interceptors: this._pipeSub(this._config.interceptors, VigorAllInterceptors, func, "interceptors")
+            interceptors: this._pipsub(this._config.interceptors, func, VigorAllInterceptors)
         });
     }
     async request() {
         const config = this._config;
         let ctx = {
-            target: [...config.target],
             setting: { ...config.setting },
+            target: [...config.target],
             interceptors: {
                 before: [...config.interceptors.before],
                 after: [...config.interceptors.after],
                 onError: [...config.interceptors.onError],
-                result: [...config.interceptors.result]
+                result: [...config.interceptors.result],
             },
             runtime: {
                 tasks: [],
-                result: []
+                result: [],
             }
         };
-        if (ctx.target?.length == 0)
-            throw new VigorFetchError("request expects 'target'", {
-                type: "invalid_input", method: "request", data: {
-                    expected: "string", received: ctx.target
-                }
+        if (ctx.target.length == 0)
+            throw new VigorAllError("TARGET_MISSING", {
+                method: "request",
+                data: undefined
             });
         let active = 0;
         const queue = [];
         const runTask = async (task) => {
             await new Promise(resolve => {
-                if (active < ctx.setting.concurrency) {
+                if (active < config.setting.concurrency) {
                     active++;
                     resolve();
                 }
@@ -668,29 +653,42 @@ class VigorAll extends VigorStatus {
                 }
             });
             const throwError = (error) => { throw error; };
+            let ctxTask = {
+                target: task,
+                runtime: {
+                    result: EMPTY,
+                    error: null,
+                    jitter: VigorRetryBackoff.randomJitter(config.setting.jitter)
+                }
+            };
             try {
-                await new Promise(resolve => setTimeout(resolve, calculateJitter(ctx.setting.jitter)));
-                let res;
-                for (const func of ctx.interceptors.before) {
-                    await func(ctx, { throwError });
+                await new Promise(resolve => setTimeout(resolve, ctxTask.runtime.jitter));
+                for (const func of config.interceptors.before) {
+                    await func(ctxTask, { throwError });
                 }
-                res = await task(ctx, {});
-                const setResult = (result) => res = result;
-                for (const func of ctx.interceptors.after) {
-                    await func(ctx, { setResult, throwError });
+                ctxTask.runtime.result = await task(ctxTask, {});
+                const setResult = (result) => ctxTask.runtime.result = result;
+                for (const func of config.interceptors.after) {
+                    await func(ctxTask, { setResult, throwError });
                 }
-                return res;
+                if (ctxTask.runtime.result === EMPTY) {
+                    throw new Error("Result not set");
+                }
+                return ctxTask.runtime.result;
             }
             catch (error) {
-                let res;
+                ctxTask.runtime.error = error;
                 let overrided = false;
-                const setResult = (result) => { overrided = true; return (res = result); };
-                for (const func of ctx.interceptors.onError) {
-                    await func(ctx, { setResult, throwError });
+                const setResult = (result) => {
+                    overrided = true;
+                    return (ctxTask.runtime.result = result);
+                };
+                for (const func of config.interceptors.onError) {
+                    await func(ctxTask, { setResult, throwError });
                 }
-                if (overrided && res !== undefined)
-                    return res;
-                throw error;
+                if (overrided && ctxTask.runtime.result !== EMPTY)
+                    return ctxTask.runtime.result;
+                throw ctxTask.runtime.error;
             }
             finally {
                 active--;
@@ -701,26 +699,28 @@ class VigorAll extends VigorStatus {
         };
         ctx.runtime.tasks = ctx.target.map(task => runTask(task));
         const settled = await Promise.allSettled(ctx.runtime.tasks);
-        ctx.runtime.result = settled.map(i => {
-            if (i.status === "fulfilled")
-                return i.value;
-            return new VigorAllError(`this request failed`, {
-                method: "request", type: "request_failed", data: {
-                    error: i.reason
+        const isFailed = Symbol("FAILED");
+        ctx.runtime.result = settled.map((res, idx) => {
+            if (res.status === "fulfilled")
+                return res.value;
+            if (ctx.setting.onlySuccess)
+                return isFailed;
+            return new VigorAllError("REQUEST_FAILED", {
+                method: "request",
+                data: {
+                    index: idx,
+                    error: res.reason
                 }
             });
-        });
+        }).filter(i => i !== isFailed);
         const setResult = (result) => ctx.runtime.result = result;
         const throwError = (error) => { throw error; };
-        for (const func of ctx.interceptors.result) {
+        for (const func of config.interceptors.result) {
             await func(ctx, { setResult, throwError });
         }
         return ctx.runtime.result;
     }
 }
-function calculateJitter(jitter) {
-    return jitter * (Math.random() * 2 - 1);
-}
 class Vigor {
     registry;
     constructor(config) {
@@ -754,8 +754,11 @@ class Vigor {
     fetch(origin) {
         return this.registry.VigorFetch.main().origin(origin);
     }
-    all(tasks) {
-        return this.registry.VigorAll.main().target(tasks.flat());
+    all(...args) {
+        const flatTasks = args.flat();
+        return this.registry.VigorAll
+            .main()
+            .target(...flatTasks);
     }
     parse(response) {
         return this.registry.VigorParse.main().target(response);