vigor-fetch 3.1.3 → 3.1.5

package/dist/index.d.ts

@@ -120,6 +120,7 @@ type VigorRetryAlgorithmsConstantConfig = {
 declare class VigorRetryAlgorithmsConstant extends VigorStatus<VigorRetryAlgorithmsConstantConfig, VigorRetryAlgorithmsConstant> {
     constructor(config?: Partial<VigorRetryAlgorithmsConstantConfig>);
     interval(num: VigorRetryAlgorithmsConstantConfig["interval"]): VigorRetryAlgorithmsConstant;
+    _calculateDelay(attempt: number): number;
 }
 type VigorRetryAlgorithmsLinearConfig = {
     initial: number;
@@ -133,6 +134,7 @@ declare class VigorRetryAlgorithmsLinear extends VigorStatus<VigorRetryAlgorithm
     increment(num: VigorRetryAlgorithmsLinearConfig["increment"]): VigorRetryAlgorithmsLinear;
     minDelay(num: VigorRetryAlgorithmsLinearConfig["minDelay"]): VigorRetryAlgorithmsLinear;
     maxDelay(num: VigorRetryAlgorithmsLinearConfig["maxDelay"]): VigorRetryAlgorithmsLinear;
+    _calculateDelay(attempt: number): number;
 }
 type VigorRetryAlgorithmsBackoffConfig = {
     initial: number;
@@ -148,6 +150,7 @@ declare class VigorRetryAlgorithmsBackoff extends VigorStatus<VigorRetryAlgorith
     unit(num: VigorRetryAlgorithmsBackoffConfig["unit"]): VigorRetryAlgorithmsBackoff;
     minDelay(num: VigorRetryAlgorithmsBackoffConfig["minDelay"]): VigorRetryAlgorithmsBackoff;
     maxDelay(num: VigorRetryAlgorithmsBackoffConfig["maxDelay"]): VigorRetryAlgorithmsBackoff;
+    _calculateDelay(attempt: number): number;
 }
 type VigorRetryAlgorithmsCustomConfig = {
     func: VigorRetryAlgorithmsConfig;
@@ -157,6 +160,7 @@ type VigorRetryAlgorithmsCustomConfig = {
 declare class VigorRetryAlgorithmsCustom extends VigorStatus<VigorRetryAlgorithmsCustomConfig, VigorRetryAlgorithmsCustom> {
     constructor(config?: Partial<VigorRetryAlgorithmsCustomConfig>);
     func(num: VigorRetryAlgorithmsCustomConfig["func"]): VigorRetryAlgorithmsCustom;
+    _calculateDelay(attempt: number): number;
 }
 type VigorRetryAlgorithmsConfig = (attempt: number) => number;
 type VigorRetryInterceptorsApi<R> = {
@@ -260,9 +264,14 @@ type VigorRetryTimeline<I extends keyof VigorRetryInterceptorsFunctions, H exten
 };
 declare class VigorRetry extends VigorStatus<VigorRetryConfig, VigorRetry> {
     constructor(config?: Partial<VigorRetryConfig>);
-    private RetryAlgorithms;
-    private _createTimelineHandler;
-    private _createInterceptorHandler;
+    protected readonly RetryAlgorithms: {
+        constant: (config?: Partial<VigorRetryAlgorithmsConstantConfig>) => VigorRetryAlgorithmsConstant;
+        linear: (config?: Partial<VigorRetryAlgorithmsLinearConfig>) => VigorRetryAlgorithmsLinear;
+        backoff: (config?: Partial<VigorRetryAlgorithmsBackoffConfig>) => VigorRetryAlgorithmsBackoff;
+        custom: (config?: Partial<VigorRetryAlgorithmsCustomConfig>) => VigorRetryAlgorithmsCustom;
+    };
+    protected _createTimelineHandler(timeline: VigorRetryContext["timeline"]): <I extends keyof VigorRetryInterceptorsFunctions, H extends keyof VigorRetryProcessHandler, K extends keyof VigorRetryTimeline<I, H>>(action: K, content: VigorRetryTimeline<I, H>[K]) => void;
+    protected _createInterceptorHandler(ctx: VigorRetryContext, addTimeline: ReturnType<typeof this._createTimelineHandler>): <I extends keyof VigorRetryInterceptorsFunctions>(interceptorType: I, api: (interceptorType: I, func: VigorRetryInterceptorsFunctions[I]) => Pick<VigorRetryInterceptorsApi<any>, VigorRetryAllowedApis<I>>) => Promise<void>;
     target(func: VigorRetryConfig["target"]): VigorRetry;
     settings(func: ((s: VigorRetrySettings) => VigorRetrySettings) | VigorRetrySettings | VigorRetrySettings["_config"]): VigorRetry;
     interceptors(func: ((i: VigorRetryInterceptors) => VigorRetryInterceptors) | VigorRetryInterceptors | VigorRetryInterceptors["_config"]): VigorRetry;
@@ -286,9 +295,19 @@ type VigorParseStrategiesConfig = {
 };
 declare class VigorParseStrategies extends VigorStatus<VigorParseStrategiesConfig, VigorParseStrategies> {
     constructor(config?: Partial<VigorParseStrategiesConfig>);
-    private ParseAutoHeaders;
-    private ParseAutoMethods;
-    private ParseAutoAlgorithms;
+    protected readonly ParseAutoHeaders: {
+        header: string;
+        regExp: RegExp;
+        method: (res: Response) => Promise<any>;
+    }[];
+    protected readonly ParseAutoMethods: {
+        title: string;
+        method: (res: Response) => Promise<any>;
+    }[];
+    protected readonly ParseAutoAlgorithms: {
+        contentType: (response: Response) => Promise<any>;
+        sniff: (response: Response) => Promise<any>;
+    };
     contentType(): VigorParseStrategies;
     sniff(): VigorParseStrategies;
     json(): VigorParseStrategies;
@@ -377,8 +396,8 @@ type VigorParseTimeline<I extends keyof VigorParseInterceptorsFunctions, H exten
 };
 declare class VigorParse extends VigorStatus<VigorParseConfig, VigorParse> {
     constructor(config?: Partial<VigorParseConfig>);
-    private _createTimelineHandler;
-    private _createInterceptorHandler;
+    protected _createTimelineHandler(timeline: VigorParseContext["timeline"]): <I extends keyof VigorParseInterceptorsFunctions, H extends keyof VigorParseProcessHandler, K extends keyof VigorParseTimeline<I, H>>(action: K, content: VigorParseTimeline<I, H>[K]) => void;
+    protected _createInterceptorHandler(ctx: VigorParseContext, addTimeline: ReturnType<typeof this._createTimelineHandler>): <I extends keyof VigorParseInterceptorsFunctions>(interceptorType: I, api: (interceptorType: I, func: VigorParseInterceptorsFunctions[I]) => Pick<VigorParseInterceptorsApi<any>, VigorParseAllowedApis<I>>) => Promise<void>;
     target(response: VigorParseConfig["target"]): VigorParse;
     settings(func: ((i: VigorParseSettings) => VigorParseSettings) | VigorParseSettings | VigorParseSettings["_config"]): VigorParse;
     strategies(func: ((i: VigorParseStrategies) => VigorParseStrategies) | VigorParseStrategies | VigorParseStrategies["_config"]): VigorParse;
@@ -521,9 +540,9 @@ type VigorFetchTimeline<I extends keyof VigorFetchInterceptorsFunctions, H exten
 };
 declare class VigorFetch extends VigorStatus<VigorFetchConfig, VigorFetch> {
     constructor(config?: Partial<VigorFetchConfig>);
-    private _createTimelineHandler;
-    private _createInterceptorHandler;
-    private _stringifyList;
+    protected _createTimelineHandler(timeline: VigorFetchContext["timeline"]): <I extends keyof VigorFetchInterceptorsFunctions, H extends keyof VigorFetchProcessHandler, K extends keyof VigorFetchTimeline<I, H>>(action: K, content: VigorFetchTimeline<I, H>[K]) => void;
+    protected _createInterceptorHandler(ctx: VigorFetchContext, addTimeline: ReturnType<typeof this._createTimelineHandler>): <I extends keyof VigorFetchInterceptorsFunctions>(interceptorType: I, api: (interceptorType: I, func: VigorFetchInterceptorsFunctions[I]) => Pick<VigorFetchInterceptorsApi<any>, VigorFetchAllowedApis<I>>) => Promise<void>;
+    protected _stringifyList(unkList: Array<VigorStringable>): Array<string>;
     method(str: VigorFetchConfig["method"]): VigorFetch;
     origin(...strs: VigorIncludeSpread<VigorStringable>): VigorFetch;
     path(...strs: VigorIncludeSpread<VigorStringable>): VigorFetch;
@@ -532,8 +551,12 @@ declare class VigorFetch extends VigorStatus<VigorFetchConfig, VigorFetch> {
     options(obj: VigorFetchConfig["options"]): VigorFetch;
     headers(obj: VigorFetchConfig["options"]["headers"]): VigorFetch;
     body(obj: VigorFetchConfig["options"]["body"]): VigorFetch;
-    private _buildUrl;
-    private _normalizeOptions;
+    protected _buildUrl(origin: VigorFetchConfig["origin"], path: VigorFetchConfig["path"], query: VigorFetchConfig["query"], hash: VigorFetchConfig["hash"]): string;
+    protected _normalizeOptions(body: unknown): {
+        isJson: boolean;
+        headers: Record<string, unknown>;
+        body: BodyInit | null | undefined;
+    };
     settings(func: ((s: VigorFetchSettings) => VigorFetchSettings) | VigorFetchSettings | VigorFetchSettings["_config"]): VigorFetch;
     interceptors(func: ((s: VigorFetchInterceptors) => VigorFetchInterceptors) | VigorFetchInterceptors | VigorFetchInterceptors["_config"]): VigorFetch;
     retryConfig(func: ((s: VigorRetry) => VigorRetry) | VigorRetry | VigorRetry["_config"]): VigorFetch;
@@ -706,14 +729,20 @@ type VigorAllEachTimeline<I extends keyof VigorAllEachInterceptorsFunctions, H e
 };
 declare class VigorAll extends VigorStatus<VigorAllConfig, VigorAll> {
     constructor(config?: Partial<VigorAllConfig>);
-    private _createTimelineHandler;
-    private _createInterceptorHandler;
-    private _createEachTimelineHandler;
-    private _createEachInterceptorHandler;
+    protected _createTimelineHandler(timeline: VigorAllContext["timeline"]): <I extends keyof VigorAllInterceptorsFunctions, H extends keyof VigorAllProcessHandler, K extends keyof VigorAllTimeline<I, H>>(action: K, content: VigorAllTimeline<I, H>[K]) => void;
+    protected _createInterceptorHandler(ctx: VigorAllContext, addTimeline: ReturnType<typeof this._createTimelineHandler>): <I extends keyof VigorAllInterceptorsFunctions>(interceptorType: I, api: (interceptorType: I, func: VigorAllInterceptorsFunctions[I]) => Pick<VigorAllInterceptorsApi<any>, VigorAllAllowedApis<I>>) => Promise<void>;
+    protected _createEachTimelineHandler(timeline: VigorAllEachContext["timeline"]): <I extends keyof VigorAllEachInterceptorsFunctions, H extends keyof VigorAllEachProcessHandler, K extends keyof VigorAllEachTimeline<I, H>>(action: K, content: VigorAllEachTimeline<I, H>[K]) => void;
+    protected _createEachInterceptorHandler(ctx: VigorAllEachContext, addEachTimeline: ReturnType<typeof this._createEachTimelineHandler>): <I extends keyof VigorAllEachInterceptorsFunctions>(interceptorType: I, api: (interceptorType: I, func: VigorAllEachInterceptorsFunctions[I]) => Pick<VigorAllEachInterceptorsApi<any>, VigorAllEachAllowedApis<I>>) => Promise<void>;
     target(...funcs: VigorIncludeSpread<VigorAllConfig["target"][number]>): VigorAll;
     settings(func: ((s: VigorAllSettings) => VigorAllSettings) | VigorAllSettings | VigorAllSettings["_config"]): VigorAll;
     interceptors(func: ((s: VigorAllInterceptors) => VigorAllInterceptors) | VigorAllInterceptors | VigorAllInterceptors["_config"]): VigorAll;
-    private runTask;
+    protected runTask(task: VigorAllEachContext["target"], { stats, root }: {
+        stats: VigorAllEachContext["stats"];
+        root: VigorAllEachContext["root"];
+    }, semaphore: {
+        acquire: VigorAllEachContext["semaphore"]["acquire"];
+        release: VigorAllEachContext["semaphore"]["release"];
+    }): Promise<unknown>;
     request<R extends VigorAllContext["result"]>(config?: VigorAllConfig, timeline?: VigorAllContext["timeline"]): Promise<R>;
 }
 declare const VigorEntry: {

package/dist/index.js

@@ -130,7 +130,6 @@ class VigorRetryAlgorithmsConstant extends VigorStatus {
         super(config, base, (c) => new VigorRetryAlgorithmsConstant(c));
     }
     interval(num) { return this._next({ interval: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         return this._config.interval;
     }
@@ -149,7 +148,6 @@ class VigorRetryAlgorithmsLinear extends VigorStatus {
     increment(num) { return this._next({ increment: num }); }
     minDelay(num) { return this._next({ minDelay: num }); }
     maxDelay(num) { return this._next({ maxDelay: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { initial, increment, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, initial + increment * attempt));
@@ -171,7 +169,6 @@ class VigorRetryAlgorithmsBackoff extends VigorStatus {
     unit(num) { return this._next({ unit: num }); }
     minDelay(num) { return this._next({ minDelay: num }); }
     maxDelay(num) { return this._next({ maxDelay: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { initial, multiplier, unit, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, initial + unit * Math.pow(multiplier, attempt)));
@@ -187,7 +184,6 @@ class VigorRetryAlgorithmsCustom extends VigorStatus {
         super(config, base, (c) => new VigorRetryAlgorithmsCustom(c));
     }
     func(num) { return this._next({ func: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { func, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, func(attempt)));

package/dist/index.mjs

@@ -126,7 +126,6 @@ class VigorRetryAlgorithmsConstant extends VigorStatus {
         super(config, base, (c) => new VigorRetryAlgorithmsConstant(c));
     }
     interval(num) { return this._next({ interval: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         return this._config.interval;
     }
@@ -145,7 +144,6 @@ class VigorRetryAlgorithmsLinear extends VigorStatus {
     increment(num) { return this._next({ increment: num }); }
     minDelay(num) { return this._next({ minDelay: num }); }
     maxDelay(num) { return this._next({ maxDelay: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { initial, increment, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, initial + increment * attempt));
@@ -167,7 +165,6 @@ class VigorRetryAlgorithmsBackoff extends VigorStatus {
     unit(num) { return this._next({ unit: num }); }
     minDelay(num) { return this._next({ minDelay: num }); }
     maxDelay(num) { return this._next({ maxDelay: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { initial, multiplier, unit, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, initial + unit * Math.pow(multiplier, attempt)));
@@ -183,7 +180,6 @@ class VigorRetryAlgorithmsCustom extends VigorStatus {
         super(config, base, (c) => new VigorRetryAlgorithmsCustom(c));
     }
     func(num) { return this._next({ func: num }); }
-    /** @internal */
     _calculateDelay(attempt) {
         const { func, minDelay, maxDelay } = this._config;
         return Math.max(minDelay, Math.min(maxDelay, func(attempt)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigor-fetch",
-  "version": "3.1.3",
+  "version": "3.1.5",
   "description": "Smart, zero-dependency HTTP client with self-healing retries for rate-limited servers.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",