vigor-fetch 2.0.6 → 2.1.1

package/dist/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class VigorError extends Error {
-    timestamp;
+    timestamp = new Date();
     method;
     cause;
     context;
@@ -12,15 +12,10 @@ class VigorError extends Error {
     constructor(message, options) {
         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.context = options?.context;
+        this.type = options?.type;
+        this.data = options?.data;
         Object.setPrototypeOf(this, new.target.prototype);
         Error.captureStackTrace?.(this, new.target);
     }
@@ -46,114 +41,87 @@ class VigorAllError extends VigorError {
     }
 }
 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;
+        });
     }
-    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,6 +136,7 @@ class VigorRetry extends VigorStatus {
                 retryIf: [...config.interceptors.retryIf],
             },
             backoff: { ...config.backoff },
+            controller: config.controller,
             runtime: {
                 result: null,
                 controller: null,
@@ -187,7 +156,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 +165,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 +179,11 @@ 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(`timeouted after ${ctx.setting.limit}`, {
+                                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 +216,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 +226,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 +238,13 @@ 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(`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
+                }
+            });
         }
         catch (error) {
             ctx.runtime.error = error;
@@ -283,37 +261,37 @@ class VigorRetry extends VigorStatus {
         }
     }
 }
-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: {
+        if (!(config.target instanceof Response)) {
+            throw new VigorParseError(`target not found`, {
+                method: "request", type: "args_missing", data: {
                     expected: "Response",
-                    received: config.target,
-                } });
-        if (config.original)
+                    received: config.target
+                }
+            });
+        }
+        if (config.original) {
             return config.target;
+        }
         const contentType = config.target.headers.get("Content-Type") || "";
         let strategy;
         try {
@@ -323,13 +301,13 @@ class VigorParse extends VigorStatus {
                 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,
+                            supported: VigorParse.supported,
                             response: config.target,
                             headers: contentType,
                         } });
                 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) {
@@ -337,7 +315,7 @@ class VigorParse extends VigorStatus {
                 throw error;
             throw new VigorParseError(`failed to parse: '${strategy?.type ?? "unknown"}'`, { method: "request", type: "parse_failed", data: {
                     expected: strategy?.type ?? "unknown",
-                    supported: supported,
+                    supported: VigorParse.supported,
                     response: config.target,
                     headers: contentType,
                     error
@@ -346,19 +324,15 @@ class VigorParse extends VigorStatus {
     }
 }
 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;
+        });
     }
-    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 +345,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 +375,50 @@ 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 origin: ${origin}`, {
+                type: "invalid_url",
+                method: "buildUrl",
+                data: {
+                    expected: "string",
+                    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;
@@ -576,87 +529,75 @@ class VigorFetch extends VigorStatus {
     }
 }
 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;
+        });
     }
-    getBase() { return this._base; }
     concurrency(num) { return this._next({ concurrency: num }); }
     jitter(num) { return this._next({ jitter: num }); }
 }
 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;
+        });
+    }
+    target(...funcs) {
+        return this._next({
+            target: [...this._config.target, ...funcs.flat()]
+        });
     }
-    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 },
-            interceptors: {
-                before: [...config.interceptors.before],
-                after: [...config.interceptors.after],
-                onError: [...config.interceptors.onError],
-                result: [...config.interceptors.result]
-            },
             runtime: {
                 tasks: [],
                 result: []
             }
         };
-        if (ctx.target?.length == 0)
+        if (ctx.target.length == 0)
             throw new VigorFetchError("request expects 'target'", {
-                type: "invalid_input", method: "request", data: {
-                    expected: "string", received: ctx.target
+                type: "invalid_input",
+                method: "request",
+                data: {
+                    expected: "string",
+                    received: ctx.target
                 }
             });
         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();
                 }
@@ -669,14 +610,14 @@ class VigorAll extends VigorStatus {
             });
             const throwError = (error) => { throw error; };
             try {
-                await new Promise(resolve => setTimeout(resolve, calculateJitter(ctx.setting.jitter)));
+                await new Promise(resolve => setTimeout(resolve, VigorRetryBackoff.randomJitter(config.setting.jitter)));
                 let res;
-                for (const func of ctx.interceptors.before) {
+                for (const func of config.interceptors.before) {
                     await func(ctx, { throwError });
                 }
                 res = await task(ctx, {});
                 const setResult = (result) => res = result;
-                for (const func of ctx.interceptors.after) {
+                for (const func of config.interceptors.after) {
                     await func(ctx, { setResult, throwError });
                 }
                 return res;
@@ -684,8 +625,11 @@ class VigorAll extends VigorStatus {
             catch (error) {
                 let res;
                 let overrided = false;
-                const setResult = (result) => { overrided = true; return (res = result); };
-                for (const func of ctx.interceptors.onError) {
+                const setResult = (result) => {
+                    overrided = true;
+                    return (res = result);
+                };
+                for (const func of config.interceptors.onError) {
                     await func(ctx, { setResult, throwError });
                 }
                 if (overrided && res !== undefined)
@@ -705,22 +649,21 @@ class VigorAll extends VigorStatus {
             if (i.status === "fulfilled")
                 return i.value;
             return new VigorAllError(`this request failed`, {
-                method: "request", type: "request_failed", data: {
+                method: "request",
+                type: "request_failed",
+                data: {
                     error: i.reason
                 }
             });
         });
         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 +697,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);