@fetchkit/ffetch 5.0.0 → 5.1.0

package/dist/index.cjs

@@ -79,6 +79,7 @@ var index_exports = {};
 __export(index_exports, {
   AbortError: () => AbortError,
   CircuitOpenError: () => CircuitOpenError,
+  HttpError: () => HttpError,
   NetworkError: () => NetworkError,
   RetryLimitError: () => RetryLimitError,
   TimeoutError: () => TimeoutError,
@@ -97,7 +98,29 @@ var defaultDelay = (ctx) => {
   }
   return 2 ** ctx.attempt * 200 + Math.random() * 100;
 };
-async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
+function waitForRetryDelay(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    if (!signal) {
+      setTimeout(resolve, ms);
+      return;
+    }
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function retry(fn, retries, delay, shouldRetry2 = () => true, request, signal) {
   let lastErr;
   let lastRes;
   for (let i = 0; i <= retries; i++) {
@@ -113,7 +136,7 @@ async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
       ctx.error = void 0;
       if (i < retries && shouldRetry2(ctx)) {
         const wait = typeof delay === "function" ? delay(ctx) : delay;
-        await new Promise((r) => setTimeout(r, wait));
+        await waitForRetryDelay(wait, signal);
         continue;
       }
       return lastRes;
@@ -122,7 +145,7 @@ async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
       ctx.error = err;
       if (i === retries || !shouldRetry2(ctx)) throw err;
       const wait = typeof delay === "function" ? delay(ctx) : delay;
-      await new Promise((r) => setTimeout(r, wait));
+      await waitForRetryDelay(wait, signal);
     }
   }
   throw lastErr;
@@ -189,250 +212,260 @@ function createClient(opts = {}) {
       entry.controller?.abort();
     }
   }
-  const client = async (input, init = {}) => {
-    let request = new Request(input, init);
-    const effectiveHooks = { ...clientDefaultHooks, ...init.hooks || {} };
-    if (effectiveHooks.transformRequest) {
-      request = await effectiveHooks.transformRequest(request);
-    }
-    await effectiveHooks.before?.(request);
-    const effectiveRetries = init.retries ?? clientDefaultRetries;
-    const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
-    const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
-    const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
-    const userSignal = init.signal;
-    const transformedSignal = request.signal;
-    const pluginContext = {
-      request,
-      init,
-      state: /* @__PURE__ */ Object.create(null),
-      metadata: {
-        startedAt: Date.now(),
-        timeoutMs: effectiveTimeout,
-        signals: {
-          user: userSignal === void 0 || userSignal === null ? void 0 : userSignal,
-          transformed: transformedSignal
-        },
-        retry: {
-          configuredRetries: effectiveRetries,
-          configuredDelay: effectiveRetryDelay,
-          attempt: 0
-        }
+  const client = (input, init = {}) => {
+    const execute = async () => {
+      let request = new Request(input, init);
+      const effectiveHooks = { ...clientDefaultHooks, ...init.hooks || {} };
+      if (effectiveHooks.transformRequest) {
+        request = await effectiveHooks.transformRequest(request);
       }
-    };
-    for (const plugin of plugins) {
-      await plugin.preRequest?.(pluginContext);
-    }
-    const effectiveThrowOnHttpError = typeof init.throwOnHttpError !== "undefined" ? init.throwOnHttpError : opts.throwOnHttpError ?? false;
-    function createTimeoutSignal(timeout) {
-      if (typeof AbortSignal?.timeout === "function") {
-        return AbortSignal.timeout(timeout);
+      await effectiveHooks.before?.(request);
+      const effectiveRetries = init.retries ?? clientDefaultRetries;
+      const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
+      const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
+      const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
+      const userSignal = init.signal;
+      const transformedSignal = request.signal;
+      const pluginContext = {
+        request,
+        init,
+        state: /* @__PURE__ */ Object.create(null),
+        metadata: {
+          startedAt: Date.now(),
+          timeoutMs: effectiveTimeout,
+          signals: {
+            user: userSignal === void 0 || userSignal === null ? void 0 : userSignal,
+            transformed: transformedSignal
+          },
+          retry: {
+            configuredRetries: effectiveRetries,
+            configuredDelay: effectiveRetryDelay,
+            attempt: 0
+          }
+        }
+      };
+      for (const plugin of plugins) {
+        await plugin.preRequest?.(pluginContext);
       }
-      const controller2 = new AbortController();
-      const timeoutId = setTimeout(() => controller2.abort(), timeout);
-      controller2.signal.addEventListener(
-        "abort",
-        () => clearTimeout(timeoutId),
-        { once: true }
-      );
-      return controller2.signal;
-    }
-    let timeoutSignal = void 0;
-    let combinedSignal = void 0;
-    let controller = void 0;
-    if (effectiveTimeout > 0) {
-      timeoutSignal = createTimeoutSignal(effectiveTimeout);
-      pluginContext.metadata.signals.timeout = timeoutSignal;
-    }
-    const signals = [];
-    if (userSignal) signals.push(userSignal);
-    if (transformedSignal && transformedSignal !== userSignal) {
-      signals.push(transformedSignal);
-    }
-    if (timeoutSignal) signals.push(timeoutSignal);
-    if (signals.length === 1) {
-      combinedSignal = signals[0];
-      controller = new AbortController();
-    } else {
-      if (typeof AbortSignal.any !== "function") {
-        throw new Error(
-          "AbortSignal.any is required for combining multiple signals. Please install a polyfill for environments that do not support it."
+      const effectiveThrowOnHttpError = typeof init.throwOnHttpError !== "undefined" ? init.throwOnHttpError : opts.throwOnHttpError ?? false;
+      function createTimeoutSignal(timeout) {
+        if (typeof AbortSignal?.timeout === "function") {
+          return AbortSignal.timeout(timeout);
+        }
+        const controller2 = new AbortController();
+        const timeoutId = setTimeout(() => controller2.abort(), timeout);
+        controller2.signal.addEventListener(
+          "abort",
+          () => clearTimeout(timeoutId),
+          { once: true }
         );
+        return controller2.signal;
       }
-      combinedSignal = AbortSignal.any(signals);
-      controller = new AbortController();
-    }
-    pluginContext.metadata.signals.combined = combinedSignal;
-    const retryWithHooks = async () => {
-      let attempt = 0;
-      const shouldRetryWithHook = (ctx) => {
-        attempt = ctx.attempt;
-        pluginContext.metadata.retry.attempt = attempt;
-        pluginContext.metadata.retry.lastError = ctx.error;
-        pluginContext.metadata.retry.lastResponse = ctx.response;
-        const retrying = effectiveShouldRetry(ctx);
-        pluginContext.metadata.retry.shouldRetryResult = retrying;
-        if (retrying && attempt <= effectiveRetries) {
-          effectiveHooks.onRetry?.(
-            request,
-            attempt - 1,
-            ctx.error,
-            ctx.response
+      let timeoutSignal = void 0;
+      let combinedSignal = void 0;
+      let controller = void 0;
+      if (effectiveTimeout > 0) {
+        timeoutSignal = createTimeoutSignal(effectiveTimeout);
+        pluginContext.metadata.signals.timeout = timeoutSignal;
+      }
+      const signals = [];
+      if (userSignal) signals.push(userSignal);
+      if (transformedSignal && transformedSignal !== userSignal) {
+        signals.push(transformedSignal);
+      }
+      if (timeoutSignal) signals.push(timeoutSignal);
+      if (signals.length === 1) {
+        combinedSignal = signals[0];
+        controller = new AbortController();
+      } else {
+        if (typeof AbortSignal.any !== "function") {
+          throw new Error(
+            "AbortSignal.any is required for combining multiple signals. Please install a polyfill for environments that do not support it."
           );
         }
-        return retrying;
-      };
-      let lastResponse = void 0;
-      try {
-        let res = await retry(
-          async () => {
-            if (userSignal?.aborted) {
-              effectiveHooks.onAbort?.(request);
-              throw new AbortError("Request was aborted by user");
-            }
-            if (timeoutSignal?.aborted) {
-              effectiveHooks.onTimeout?.(request);
-              throw new TimeoutError("signal timed out");
-            }
-            if (typeof combinedSignal?.throwIfAborted === "function") {
-              combinedSignal.throwIfAborted();
-            } else if (combinedSignal?.aborted) {
+        combinedSignal = AbortSignal.any(signals);
+        controller = new AbortController();
+      }
+      pluginContext.metadata.signals.combined = combinedSignal;
+      const retryWithHooks = async () => {
+        let attempt = 0;
+        const shouldRetryWithHook = (ctx) => {
+          attempt = ctx.attempt;
+          pluginContext.metadata.retry.attempt = attempt;
+          pluginContext.metadata.retry.lastError = ctx.error;
+          pluginContext.metadata.retry.lastResponse = ctx.response;
+          const retrying = effectiveShouldRetry(ctx);
+          pluginContext.metadata.retry.shouldRetryResult = retrying;
+          if (retrying && attempt <= effectiveRetries) {
+            effectiveHooks.onRetry?.(
+              request,
+              attempt - 1,
+              ctx.error,
+              ctx.response
+            );
+          }
+          return retrying;
+        };
+        let lastResponse = void 0;
+        try {
+          let res = await retry(
+            async () => {
               if (userSignal?.aborted) {
                 effectiveHooks.onAbort?.(request);
                 throw new AbortError("Request was aborted by user");
-              } else if (timeoutSignal?.aborted) {
+              }
+              if (timeoutSignal?.aborted) {
                 effectiveHooks.onTimeout?.(request);
                 throw new TimeoutError("signal timed out");
-              } else {
-                throw new AbortError(
-                  "Request was aborted",
-                  new DOMException("Aborted", "AbortError")
-                );
               }
-            }
-            const reqWithSignal = new Request(request, {
-              signal: combinedSignal
-            });
-            try {
-              const handler = init.fetchHandler ?? fetchHandler ?? fetch;
-              const response = await handler(reqWithSignal);
-              lastResponse = response;
-              pluginContext.metadata.retry.lastResponse = response;
-              return response;
-            } catch (err) {
-              pluginContext.metadata.retry.lastError = err;
-              if (err instanceof DOMException && err.name === "AbortError") {
-                if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
-                  effectiveHooks.onTimeout?.(request);
-                  throw new TimeoutError("signal timed out", err);
-                } else if (userSignal?.aborted) {
+              if (typeof combinedSignal?.throwIfAborted === "function") {
+                combinedSignal.throwIfAborted();
+              } else if (combinedSignal?.aborted) {
+                if (userSignal?.aborted) {
                   effectiveHooks.onAbort?.(request);
                   throw new AbortError("Request was aborted by user");
+                } else if (timeoutSignal?.aborted) {
+                  effectiveHooks.onTimeout?.(request);
+                  throw new TimeoutError("signal timed out");
                 } else {
                   throw new AbortError(
                     "Request was aborted",
                     new DOMException("Aborted", "AbortError")
                   );
                 }
-              } else if (err instanceof TypeError && /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(
-                err.message
-              )) {
-                throw new NetworkError(err.message, err);
               }
-              throw err;
-            }
-          },
-          effectiveRetries,
-          effectiveRetryDelay,
-          shouldRetryWithHook,
-          request
-        );
-        if (effectiveHooks.transformResponse) {
-          res = await effectiveHooks.transformResponse(res, request);
-        }
-        await effectiveHooks.after?.(request, res);
-        await effectiveHooks.onComplete?.(request, res, void 0);
-        if (effectiveThrowOnHttpError && (res.status >= 400 && res.status < 500 && res.status !== 429 || res.status >= 500 || res.status === 429)) {
-          const { HttpError: HttpError2 } = await Promise.resolve().then(() => (init_error(), error_exports));
-          throw new HttpError2(
-            `HTTP error: ${res.status} ${res.statusText}`,
-            res
+              const reqWithSignal = new Request(request, {
+                signal: combinedSignal
+              });
+              try {
+                const handler = init.fetchHandler ?? fetchHandler ?? fetch;
+                const response = await handler(reqWithSignal);
+                lastResponse = response;
+                pluginContext.metadata.retry.lastResponse = response;
+                return response;
+              } catch (err) {
+                pluginContext.metadata.retry.lastError = err;
+                if (err instanceof DOMException && err.name === "AbortError") {
+                  if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
+                    effectiveHooks.onTimeout?.(request);
+                    throw new TimeoutError("signal timed out", err);
+                  } else if (userSignal?.aborted) {
+                    effectiveHooks.onAbort?.(request);
+                    throw new AbortError("Request was aborted by user");
+                  } else {
+                    throw new AbortError(
+                      "Request was aborted",
+                      new DOMException("Aborted", "AbortError")
+                    );
+                  }
+                } else if (err instanceof TypeError && /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(
+                  err.message
+                )) {
+                  throw new NetworkError(err.message, err);
+                }
+                throw err;
+              }
+            },
+            effectiveRetries,
+            effectiveRetryDelay,
+            shouldRetryWithHook,
+            request,
+            combinedSignal
           );
-        }
-        return res;
-      } catch (err) {
-        pluginContext.metadata.retry.lastError = err;
-        if (lastResponse) {
-          const resp = lastResponse;
-          if (effectiveThrowOnHttpError && (resp.status >= 400 && resp.status < 500 && resp.status !== 429 || resp.status >= 500 || resp.status === 429)) {
+          if (effectiveHooks.transformResponse) {
+            res = await effectiveHooks.transformResponse(res, request);
+          }
+          await effectiveHooks.after?.(request, res);
+          await effectiveHooks.onComplete?.(request, res, void 0);
+          if (effectiveThrowOnHttpError && (res.status >= 400 && res.status < 500 && res.status !== 429 || res.status >= 500 || res.status === 429)) {
             const { HttpError: HttpError2 } = await Promise.resolve().then(() => (init_error(), error_exports));
             throw new HttpError2(
-              `HTTP error: ${resp.status} ${resp.statusText}`,
-              resp
+              `HTTP error: ${res.status} ${res.statusText}`,
+              res
             );
           }
-          return resp;
+          return res;
+        } catch (err) {
+          pluginContext.metadata.retry.lastError = err;
+          if (lastResponse) {
+            const resp = lastResponse;
+            if (effectiveThrowOnHttpError && (resp.status >= 400 && resp.status < 500 && resp.status !== 429 || resp.status >= 500 || resp.status === 429)) {
+              const { HttpError: HttpError2 } = await Promise.resolve().then(() => (init_error(), error_exports));
+              throw new HttpError2(
+                `HTTP error: ${resp.status} ${resp.statusText}`,
+                resp
+              );
+            }
+            return resp;
+          }
+          if (err instanceof TimeoutError) {
+            await effectiveHooks.onTimeout?.(request);
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          if (err instanceof AbortError) {
+            await effectiveHooks.onAbort?.(request);
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          if (err instanceof NetworkError) {
+            await effectiveHooks.onError?.(request, err);
+            await effectiveHooks.onComplete?.(request, void 0, err);
+            throw err;
+          }
+          const retryErr = new RetryLimitError(
+            typeof err === "object" && err && "message" in err && typeof err.message === "string" ? err.message : "Retry limit reached",
+            err
+          );
+          await effectiveHooks.onError?.(request, retryErr);
+          await effectiveHooks.onComplete?.(request, void 0, retryErr);
+          throw retryErr;
         }
-        if (err instanceof TimeoutError) {
-          await effectiveHooks.onTimeout?.(request);
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+      };
+      const baseDispatch = async () => retryWithHooks();
+      let dispatch = baseDispatch;
+      for (let i = plugins.length - 1; i >= 0; i--) {
+        const plugin = plugins[i];
+        if (plugin.wrapDispatch) {
+          dispatch = plugin.wrapDispatch(dispatch);
         }
-        if (err instanceof AbortError) {
-          await effectiveHooks.onAbort?.(request);
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+      }
+      const actualPromise = dispatch(pluginContext).then(async (response) => {
+        for (const plugin of plugins) {
+          await plugin.onSuccess?.(pluginContext, response);
         }
-        if (err instanceof NetworkError) {
-          await effectiveHooks.onError?.(request, err);
-          await effectiveHooks.onComplete?.(request, void 0, err);
-          throw err;
+        return response;
+      }).catch(async (err) => {
+        for (const plugin of plugins) {
+          await plugin.onError?.(pluginContext, err);
         }
-        const retryErr = new RetryLimitError(
-          typeof err === "object" && err && "message" in err && typeof err.message === "string" ? err.message : "Retry limit reached",
-          err
-        );
-        await effectiveHooks.onError?.(request, retryErr);
-        await effectiveHooks.onComplete?.(request, void 0, retryErr);
-        throw retryErr;
-      }
+        throw err;
+      });
+      const pendingEntry = {
+        promise: actualPromise,
+        request,
+        controller
+      };
+      pendingRequests.push(pendingEntry);
+      return actualPromise.finally(async () => {
+        for (const plugin of plugins) {
+          await plugin.onFinally?.(pluginContext);
+        }
+        const index = pendingRequests.indexOf(pendingEntry);
+        if (index > -1) {
+          pendingRequests.splice(index, 1);
+        }
+      });
     };
-    const baseDispatch = async () => retryWithHooks();
-    let dispatch = baseDispatch;
-    for (let i = plugins.length - 1; i >= 0; i--) {
-      const plugin = plugins[i];
-      if (plugin.wrapDispatch) {
-        dispatch = plugin.wrapDispatch(dispatch);
+    let promise = execute();
+    for (const plugin of plugins) {
+      if (plugin.decoratePromise) {
+        promise = plugin.decoratePromise(promise);
       }
     }
-    const actualPromise = dispatch(pluginContext).then(async (response) => {
-      for (const plugin of plugins) {
-        await plugin.onSuccess?.(pluginContext, response);
-      }
-      return response;
-    }).catch(async (err) => {
-      for (const plugin of plugins) {
-        await plugin.onError?.(pluginContext, err);
-      }
-      throw err;
-    });
-    const pendingEntry = {
-      promise: actualPromise,
-      request,
-      controller
-    };
-    pendingRequests.push(pendingEntry);
-    return actualPromise.finally(async () => {
-      for (const plugin of plugins) {
-        await plugin.onFinally?.(pluginContext);
-      }
-      const index = pendingRequests.indexOf(pendingEntry);
-      if (index > -1) {
-        pendingRequests.splice(index, 1);
-      }
-    });
+    return promise;
   };
   Object.defineProperty(client, "pendingRequests", {
     get() {
@@ -457,6 +490,7 @@ init_error();
 0 && (module.exports = {
   AbortError,
   CircuitOpenError,
+  HttpError,
   NetworkError,
   RetryLimitError,
   TimeoutError,