@fetchkit/ffetch 3.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gkoos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+![npm](https://img.shields.io/npm/v/@gkoos/ffetch)
+![Downloads](https://img.shields.io/npm/dm/@gkoos/ffetch)
+![GitHub stars](https://img.shields.io/github/stars/gkoos/ffetch?style=social)
+
+![Build](https://github.com/gkoos/ffetch/actions/workflows/ci.yml/badge.svg)
+![codecov](https://codecov.io/gh/gkoos/ffetch/branch/main/graph/badge.svg)
+
+![MIT](https://img.shields.io/npm/l/@gkoos/ffetch)
+![bundlephobia](https://badgen.net/bundlephobia/minzip/@gkoos/ffetch)
+![Types](https://img.shields.io/npm/types/@gkoos/ffetch)
+
+# @gkoos/ffetch
+
+**A production-ready TypeScript-first drop-in replacement for native fetch, or any fetch-compatible implementation.**
+
+ffetch can wrap any fetch-compatible implementation (native fetch, node-fetch, undici, or framework-provided fetch), making it flexible for SSR, edge, and custom environments.
+
+**Key Features:**
+
+- **Timeouts** – per-request or global
+- **Retries** – exponential backoff + jitter
+- **Circuit breaker** – automatic failure protection
+- **Hooks** – logging, auth, metrics, request/response transformation
+- **Pending requests** – real-time monitoring of active requests
+- **Per-request overrides** – customize behavior on a per-request basis
+- **Universal** – Node.js, Browser, Cloudflare Workers, React Native
+- **Zero runtime deps** – ships as dual ESM/CJS
+
+## Quick Start
+
+### Install
+
+```bash
+npm install @gkoos/ffetch
+```
+
+### Basic Usage
+
+```typescript
+import createClient from '@gkoos/ffetch'
+
+// Create a client with timeout and retries
+const api = createClient({
+  timeout: 5000,
+  retries: 3,
+  retryDelay: ({ attempt }) => 2 ** attempt * 100 + Math.random() * 100,
+})
+
+// Make requests
+const response = await api('https://api.example.com/users')
+const data = await response.json()
+```
+
+### Using a Custom fetchHandler (SSR, metaframeworks, or polyfills)
+
+```typescript
+// Example: SvelteKit, Next.js, Nuxt, or node-fetch
+import createClient from '@gkoos/ffetch'
+
+// Pass your framework's fetch implementation
+const api = createClient({
+  fetchHandler: fetch, // SvelteKit/Next.js/Nuxt provide their own fetch
+  timeout: 5000,
+})
+
+// Or use node-fetch/undici in Node.js
+import nodeFetch from 'node-fetch'
+const apiNode = createClient({ fetchHandler: nodeFetch })
+
+// All ffetch features work identically
+const response = await api('/api/data')
+```
+
+### Advanced Example
+
+```typescript
+// Production-ready client with error handling and monitoring
+const client = createClient({
+  timeout: 10000,
+  retries: 2,
+  circuit: { threshold: 5, reset: 30000 },
+  fetchHandler: fetch, // Use custom fetch if needed
+  hooks: {
+    before: async (req) => console.log('→', req.url),
+    after: async (req, res) => console.log('←', res.status),
+    onError: async (req, err) => console.error('Error:', err.message),
+    onCircuitOpen: (req) => console.warn('Circuit opened due to:', req.url),
+    onCircuitClose: (req) => console.info('Circuit closed after:', req.url),
+  },
+})
+
+try {
+  const response = await client('/api/data')
+
+  // Check HTTP status manually (like native fetch)
+  if (!response.ok) {
+    console.log('HTTP error:', response.status)
+    return
+  }
+
+  const data = await response.json()
+  console.log('Active requests:', client.pendingRequests.length)
+} catch (err) {
+  if (err instanceof TimeoutError) {
+    console.log('Request timed out')
+  } else if (err instanceof RetryLimitError) {
+    console.log('Request failed after retries')
+  }
+}
+```
+
+## Documentation
+
+| Topic                                         | Description                                                               |
+| --------------------------------------------- | ------------------------------------------------------------------------- |
+| **[Complete Documentation](./docs/index.md)** | **Start here** - Documentation index and overview                         |
+| **[API Reference](./docs/api.md)**            | Complete API documentation and configuration options                      |
+| **[Advanced Features](./docs/advanced.md)**   | Per-request overrides, pending requests, circuit breakers, custom errors  |
+| **[Hooks & Transformation](./docs/hooks.md)** | Lifecycle hooks, authentication, logging, request/response transformation |
+| **[Usage Examples](./docs/examples.md)**      | Real-world patterns: REST clients, GraphQL, file uploads, microservices   |
+| **[Compatibility](./docs/compatibility.md)**  | Browser/Node.js support, polyfills, framework integration                 |
+
+## Environment Requirements
+
+`ffetch` requires modern AbortSignal APIs:
+
+- **Node.js 20.6+** (for AbortSignal.any)
+- **Modern browsers** (Chrome 117+, Firefox 117+, Safari 17+, Edge 117+)
+
+If your environment does not support `AbortSignal.any` (Node.js < 20.6, older browsers), you **must install a polyfill** before using ffetch. See the [compatibility guide](./docs/compatibility.md) for instructions.
+
+**Custom fetch support:**
+You can pass any fetch-compatible implementation (native fetch, node-fetch, undici, SvelteKit, Next.js, Nuxt, or a polyfill) via the `fetchHandler` option. This makes ffetch fully compatible with SSR, edge, metaframework environments, custom backends, and test runners.
+
+#### "AbortSignal.any is not a function"
+
+```
+Solution: Install a polyfill for AbortSignal.any
+npm install abort-controller-x
+```
+
+## CDN Usage
+
+```html
+<script type="module">
+  import createClient from 'https://unpkg.com/@gkoos/ffetch/dist/index.min.js'
+
+  const api = createClient({ timeout: 5000 })
+  const data = await api('/api/data').then((r) => r.json())
+</script>
+```
+
+## Fetch vs. Axios vs. `ffetch`
+
+| Feature              | Native Fetch              | Axios                | ffetch                                                                                 |
+| -------------------- | ------------------------- | -------------------- | -------------------------------------------------------------------------------------- |
+| Timeouts             | ❌ Manual AbortController | ✅ Built-in          | ✅ Built-in with fallbacks                                                             |
+| Retries              | ❌ Manual implementation  | ❌ Manual or plugins | ✅ Smart exponential backoff                                                           |
+| Circuit Breaker      | ❌ Not available          | ❌ Manual or plugins | ✅ Automatic failure protection                                                        |
+| Request Monitoring   | ❌ Manual tracking        | ❌ Manual tracking   | ✅ Built-in pending requests                                                           |
+| Error Types          | ❌ Generic errors         | ⚠️ HTTP errors only  | ✅ Specific error classes                                                              |
+| TypeScript           | ⚠️ Basic types            | ⚠️ Basic types       | ✅ Full type safety                                                                    |
+| Hooks/Middleware     | ❌ Not available          | ✅ Interceptors      | ✅ Comprehensive lifecycle hooks                                                       |
+| Bundle Size          | ✅ Native (0kb)           | ❌ ~13kb minified    | ✅ ~3kb minified                                                                       |
+| Modern APIs          | ✅ Web standards          | ❌ XMLHttpRequest    | ✅ Fetch + modern features                                                             |
+| Custom Fetch Support | ❌ No (global only)       | ❌ No                | ✅ Yes (wrap any fetch-compatible implementation, including framework or custom fetch) |
+
+## Contributing
+
+- **Issues**: [GitHub Issues](https://github.com/gkoos/ffetch/issues)
+- **Pull Requests**: [GitHub PRs](https://github.com/gkoos/ffetch/pulls)
+- **Documentation**: Found in `./docs/` - PRs welcome!
+
+## License
+
+MIT © 2025 gkoos

package/dist/index.cjs

@@ -0,0 +1,423 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbortError: () => AbortError,
+  CircuitOpenError: () => CircuitOpenError,
+  NetworkError: () => NetworkError,
+  RetryLimitError: () => RetryLimitError,
+  TimeoutError: () => TimeoutError,
+  createClient: () => createClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/retry.ts
+var defaultDelay = (ctx) => {
+  const retryAfter = ctx.response?.headers.get("Retry-After");
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) return seconds * 1e3;
+    const date = Date.parse(retryAfter);
+    if (!isNaN(date)) return Math.max(0, date - Date.now());
+  }
+  return 2 ** ctx.attempt * 200 + Math.random() * 100;
+};
+async function retry(fn, retries, delay, shouldRetry2 = () => true, request) {
+  let lastErr;
+  let lastRes;
+  for (let i = 0; i <= retries; i++) {
+    const ctx = {
+      attempt: i + 1,
+      request,
+      response: lastRes,
+      error: lastErr
+    };
+    try {
+      lastRes = await fn();
+      ctx.response = lastRes;
+      ctx.error = void 0;
+      if (i < retries && shouldRetry2(ctx)) {
+        const wait = typeof delay === "function" ? delay(ctx) : delay;
+        await new Promise((r) => setTimeout(r, wait));
+        continue;
+      }
+      return lastRes;
+    } catch (err) {
+      lastErr = err;
+      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));
+    }
+  }
+  throw lastErr;
+}
+
+// src/error.ts
+var BaseError = class extends Error {
+  constructor(name, message, cause) {
+    super(message);
+    this.name = name;
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var TimeoutError = class extends BaseError {
+  constructor(message = "Request timed out", cause) {
+    super("TimeoutError", message, cause);
+  }
+};
+var CircuitOpenError = class extends BaseError {
+  constructor(message = "Circuit is open", cause) {
+    super("CircuitOpenError", message, cause);
+  }
+};
+var AbortError = class extends BaseError {
+  constructor(message = "Request was aborted", cause) {
+    super("AbortError", message, cause);
+  }
+};
+var RetryLimitError = class extends BaseError {
+  constructor(message = "Retry limit reached", cause) {
+    super("RetryLimitError", message, cause);
+  }
+};
+var NetworkError = class extends BaseError {
+  constructor(message = "Network error occurred", cause) {
+    super("NetworkError", message, cause);
+  }
+};
+
+// src/should-retry.ts
+function shouldRetry(ctx) {
+  const { error, response } = ctx;
+  if (error instanceof AbortError || error instanceof CircuitOpenError || error instanceof TimeoutError)
+    return false;
+  if (!response) return true;
+  return response.status >= 500 || response.status === 429;
+}
+
+// src/circuit.ts
+var CircuitBreaker = class {
+  constructor(threshold, resetTimeout) {
+    this.threshold = threshold;
+    this.resetTimeout = resetTimeout;
+    this.failures = 0;
+    this.nextAttempt = 0;
+    this.isOpen = false;
+  }
+  // Returns true if the circuit breaker is currently open (blocking requests).
+  get open() {
+    return this.isOpen;
+  }
+  // Call this after each request to record the result and update circuit state.
+  // Returns true if the result was counted as a failure.
+  recordResult(response, error, req) {
+    if (error && !(error instanceof RetryLimitError)) {
+      this.setLastOpenRequest(req);
+      this.onFailure();
+      return true;
+    }
+    if (response && (response.status >= 500 || response.status === 429)) {
+      this.setLastOpenRequest(req);
+      this.onFailure();
+      return true;
+    }
+    if (req) this.setLastSuccessRequest(req);
+    this.onSuccess();
+    return false;
+  }
+  setHooks(hooks) {
+    this.hooks = hooks;
+  }
+  setLastOpenRequest(req) {
+    this.lastOpenRequest = req;
+  }
+  setLastSuccessRequest(req) {
+    this.lastSuccessRequest = req;
+  }
+  async invoke(fn) {
+    if (Date.now() < this.nextAttempt)
+      throw new CircuitOpenError("Circuit is open");
+    try {
+      const res = await fn();
+      this.onSuccess();
+      return res;
+    } catch (err) {
+      this.onFailure();
+      throw err;
+    }
+  }
+  onSuccess() {
+    const wasOpen = this.isOpen;
+    this.failures = 0;
+    if (wasOpen) {
+      this.isOpen = false;
+      if (this.hooks?.onCircuitClose && this.lastSuccessRequest) {
+        this.hooks.onCircuitClose(this.lastSuccessRequest);
+      }
+    }
+    this.lastSuccessRequest = void 0;
+  }
+  onFailure() {
+    this.failures++;
+    if (this.failures >= this.threshold) {
+      this.nextAttempt = Date.now() + this.resetTimeout;
+      this.isOpen = true;
+      if (this.hooks?.onCircuitOpen && this.lastOpenRequest) {
+        this.hooks.onCircuitOpen(this.lastOpenRequest);
+      }
+    }
+  }
+};
+
+// src/client.ts
+function createClient(opts = {}) {
+  const {
+    timeout: clientDefaultTimeout = 5e3,
+    retries: clientDefaultRetries = 0,
+    retryDelay: clientDefaultRetryDelay = defaultDelay,
+    shouldRetry: clientDefaultShouldRetry = shouldRetry,
+    hooks: clientDefaultHooks = {},
+    circuit: clientDefaultCircuit,
+    fetchHandler
+  } = opts;
+  const breaker = clientDefaultCircuit ? new CircuitBreaker(
+    clientDefaultCircuit.threshold,
+    clientDefaultCircuit.reset
+  ) : null;
+  if (breaker && (clientDefaultHooks.onCircuitClose || clientDefaultHooks.onCircuitOpen)) {
+    breaker.setHooks({
+      onCircuitClose: clientDefaultHooks.onCircuitClose,
+      onCircuitOpen: clientDefaultHooks.onCircuitOpen
+    });
+  }
+  const pendingRequests = [];
+  function abortAll() {
+    for (const entry of pendingRequests) {
+      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);
+    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;
+    }
+    const effectiveTimeout = init.timeout ?? clientDefaultTimeout;
+    const userSignal = init.signal;
+    const transformedSignal = request.signal;
+    let timeoutSignal = void 0;
+    let combinedSignal = void 0;
+    let controller = void 0;
+    if (effectiveTimeout > 0) {
+      timeoutSignal = createTimeoutSignal(effectiveTimeout);
+    }
+    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."
+        );
+      }
+      combinedSignal = AbortSignal.any(signals);
+      controller = new AbortController();
+    }
+    const retryWithHooks = async () => {
+      const effectiveRetries = init.retries ?? clientDefaultRetries;
+      const effectiveRetryDelay = typeof init.retryDelay !== "undefined" ? init.retryDelay : clientDefaultRetryDelay;
+      const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry;
+      let attempt = 0;
+      const shouldRetryWithHook = (ctx) => {
+        attempt = ctx.attempt;
+        const retrying = effectiveShouldRetry(ctx);
+        if (retrying && attempt <= effectiveRetries) {
+          effectiveHooks.onRetry?.(
+            request,
+            attempt - 1,
+            ctx.error,
+            ctx.response
+          );
+        }
+        return retrying;
+      };
+      function mapToCustomError(err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {
+            return new TimeoutError("signal timed out", err);
+          } else {
+            return new AbortError("Request was aborted", err);
+          }
+        } else if (err instanceof TypeError && /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(
+          err.message
+        )) {
+          return new NetworkError(err.message, err);
+        }
+        return err;
+      }
+      async function handleError(err) {
+        err = mapToCustomError(err);
+        if (userSignal?.aborted) {
+          const abortErr = new AbortError("Request was aborted by user");
+          await effectiveHooks.onAbort?.(request);
+          await effectiveHooks.onError?.(request, abortErr);
+          await effectiveHooks.onComplete?.(request, void 0, abortErr);
+          throw abortErr;
+        }
+        if (err instanceof TimeoutError || err instanceof NetworkError || err instanceof AbortError) {
+          if (err instanceof TimeoutError) {
+            await effectiveHooks.onTimeout?.(request);
+          }
+          if (err instanceof AbortError) {
+            await effectiveHooks.onAbort?.(request);
+          }
+          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"
+        );
+        await effectiveHooks.onError?.(request, retryErr);
+        await effectiveHooks.onComplete?.(request, void 0, retryErr);
+        throw retryErr;
+      }
+      try {
+        let res = await retry(
+          async () => {
+            if (typeof combinedSignal?.throwIfAborted === "function") {
+              combinedSignal.throwIfAborted();
+            } else if (combinedSignal?.aborted) {
+              throw new AbortError("Request was aborted");
+            }
+            const reqWithSignal = new Request(request, {
+              signal: combinedSignal
+            });
+            try {
+              const handler = fetchHandler ?? fetch;
+              const response = await handler(reqWithSignal);
+              if (breaker) {
+                if (breaker.recordResult(response, void 0, request)) {
+                  throw new Error(`HTTP error: ${response.status}`);
+                }
+              }
+              return response;
+            } catch (err) {
+              if (breaker) breaker.recordResult(void 0, err, request);
+              throw mapToCustomError(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);
+        return res;
+      } catch (err) {
+        await handleError(err);
+        throw new Error("Unreachable: handleError should always throw");
+      }
+    };
+    const promise = breaker ? breaker.invoke(retryWithHooks).catch(async (err) => {
+      if (err instanceof CircuitOpenError) {
+        await effectiveHooks.onCircuitOpen?.(request);
+        await effectiveHooks.onError?.(request, err);
+        await effectiveHooks.onComplete?.(request, void 0, err);
+      } else {
+        await effectiveHooks.onError?.(request, err);
+        await effectiveHooks.onComplete?.(request, void 0, err);
+      }
+      throw err;
+    }) : retryWithHooks();
+    const entry = {
+      promise,
+      request,
+      controller
+    };
+    pendingRequests.push(entry);
+    return promise.finally(() => {
+      const index = pendingRequests.indexOf(entry);
+      if (index > -1) {
+        pendingRequests.splice(index, 1);
+      }
+    });
+  };
+  Object.defineProperty(client, "pendingRequests", {
+    get() {
+      return pendingRequests;
+    },
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(client, "abortAll", {
+    value: abortAll,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.defineProperty(client, "circuitOpen", {
+    get() {
+      return breaker ? breaker.open : false;
+    },
+    enumerable: true
+  });
+  return client;
+}
+
+// src/index.ts
+var index_default = createClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortError,
+  CircuitOpenError,
+  NetworkError,
+  RetryLimitError,
+  TimeoutError,
+  createClient
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/retry.ts","../src/error.ts","../src/should-retry.ts","../src/circuit.ts","../src/client.ts"],"sourcesContent":["export type { FFetch, FFetchOptions } from './types'\nexport type { Hooks } from './hooks'\n\nimport { createClient } from './client'\nexport { createClient } from './client'\n\nexport {\n  TimeoutError,\n  CircuitOpenError,\n  AbortError,\n  RetryLimitError,\n  NetworkError,\n} from './error'\n\nexport default createClient\n","import type { RetryContext } from './types.js'\n\nexport type RetryDelay = number | ((ctx: RetryContext) => number)\n\nexport const defaultDelay: RetryDelay = (ctx) => {\n  const retryAfter = ctx.response?.headers.get('Retry-After')\n  if (retryAfter) {\n    const seconds = parseInt(retryAfter, 10)\n    if (!isNaN(seconds)) return seconds * 1000\n    const date = Date.parse(retryAfter)\n    if (!isNaN(date)) return Math.max(0, date - Date.now())\n  }\n  return 2 ** ctx.attempt * 200 + Math.random() * 100\n}\n\nexport async function retry(\n  fn: () => Promise<Response>,\n  retries: number,\n  delay: RetryDelay,\n  shouldRetry: (ctx: RetryContext) => boolean = () => true,\n  request: Request\n): Promise<Response> {\n  let lastErr: unknown\n  let lastRes: Response | undefined\n\n  for (let i = 0; i <= retries; i++) {\n    const ctx: RetryContext = {\n      attempt: i + 1,\n      request,\n      response: lastRes,\n      error: lastErr,\n    }\n    try {\n      lastRes = await fn()\n      ctx.response = lastRes\n      ctx.error = undefined\n      if (i < retries && shouldRetry(ctx)) {\n        const wait = typeof delay === 'function' ? delay(ctx) : delay\n        await new Promise((r) => setTimeout(r, wait))\n        continue\n      }\n      return lastRes\n    } catch (err) {\n      lastErr = err\n      ctx.error = err\n      if (i === retries || !shouldRetry(ctx)) throw err\n      const wait = typeof delay === 'function' ? delay(ctx) : delay\n      await new Promise((r) => setTimeout(r, wait))\n    }\n  }\n  throw lastErr\n}\n","// Base error class to reduce duplication\nclass BaseError extends Error {\n  public cause?: unknown\n  constructor(name: string, message: string, cause?: unknown) {\n    super(message)\n    this.name = name\n    if (cause !== undefined) this.cause = cause\n  }\n}\n\nexport class TimeoutError extends BaseError {\n  constructor(message = 'Request timed out', cause?: unknown) {\n    super('TimeoutError', message, cause)\n  }\n}\n\nexport class CircuitOpenError extends BaseError {\n  constructor(message = 'Circuit is open', cause?: unknown) {\n    super('CircuitOpenError', message, cause)\n  }\n}\n\nexport class AbortError extends BaseError {\n  constructor(message = 'Request was aborted', cause?: unknown) {\n    super('AbortError', message, cause)\n  }\n}\n\nexport class RetryLimitError extends BaseError {\n  constructor(message = 'Retry limit reached', cause?: unknown) {\n    super('RetryLimitError', message, cause)\n  }\n}\n\nexport class NetworkError extends BaseError {\n  constructor(message = 'Network error occurred', cause?: unknown) {\n    super('NetworkError', message, cause)\n  }\n}\n","import { AbortError, CircuitOpenError, TimeoutError } from './error.js'\nimport type { RetryContext } from './types.js'\n\nexport function shouldRetry(ctx: RetryContext): boolean {\n  const { error, response } = ctx\n  if (\n    error instanceof AbortError ||\n    error instanceof CircuitOpenError ||\n    error instanceof TimeoutError\n  )\n    return false\n  if (!response) return true // network error\n  return response.status >= 500 || response.status === 429\n}\n","import { CircuitOpenError, RetryLimitError } from './error.js'\n\nexport class CircuitBreaker {\n  private failures = 0\n  private nextAttempt = 0\n  private isOpen = false\n\n  // Returns true if the circuit breaker is currently open (blocking requests).\n  get open(): boolean {\n    return this.isOpen\n  }\n  private hooks?: {\n    onCircuitOpen?: (req: Request) => void | Promise<void>\n    onCircuitClose?: (req: Request) => void | Promise<void>\n  }\n  private lastSuccessRequest?: Request\n  private lastOpenRequest?: Request\n\n  constructor(\n    private threshold: number,\n    private resetTimeout: number\n  ) {}\n\n  // Call this after each request to record the result and update circuit state.\n  // Returns true if the result was counted as a failure.\n  recordResult(response?: Response, error?: unknown, req?: Request): boolean {\n    // Count thrown errors (network, abort, timeout) as failures\n    if (error && !(error instanceof RetryLimitError)) {\n      this.setLastOpenRequest(req!)\n      this.onFailure()\n      return true\n    }\n    // Count HTTP 5xx and 429 responses as failures\n    if (response && (response.status >= 500 || response.status === 429)) {\n      this.setLastOpenRequest(req!)\n      this.onFailure()\n      return true\n    }\n    // Otherwise, count as success\n    if (req) this.setLastSuccessRequest(req)\n    this.onSuccess()\n    return false\n  }\n\n  setHooks(hooks: {\n    onCircuitOpen?: (req: Request) => void | Promise<void>\n    onCircuitClose?: (req: Request) => void | Promise<void>\n  }) {\n    this.hooks = hooks\n  }\n  setLastOpenRequest(req: Request) {\n    this.lastOpenRequest = req\n  }\n\n  setLastSuccessRequest(req: Request) {\n    this.lastSuccessRequest = req\n  }\n\n  async invoke<T>(fn: () => Promise<T>): Promise<T> {\n    if (Date.now() < this.nextAttempt)\n      throw new CircuitOpenError('Circuit is open')\n    try {\n      const res = await fn()\n      this.onSuccess()\n      return res\n    } catch (err) {\n      this.onFailure()\n      throw err\n    }\n  }\n\n  private onSuccess() {\n    const wasOpen = this.isOpen\n    this.failures = 0\n    if (wasOpen) {\n      this.isOpen = false\n      if (this.hooks?.onCircuitClose && this.lastSuccessRequest) {\n        this.hooks.onCircuitClose(this.lastSuccessRequest)\n      }\n    }\n    this.lastSuccessRequest = undefined\n  }\n\n  private onFailure() {\n    this.failures++\n    if (this.failures >= this.threshold) {\n      this.nextAttempt = Date.now() + this.resetTimeout\n      this.isOpen = true\n      if (this.hooks?.onCircuitOpen && this.lastOpenRequest) {\n        this.hooks.onCircuitOpen(this.lastOpenRequest)\n      }\n    }\n  }\n}\n","import type {\n  FFetchOptions,\n  FFetch,\n  FFetchRequestInit,\n  PendingRequest,\n} from './types.js'\nimport { retry, defaultDelay } from './retry.js'\nimport { shouldRetry as defaultShouldRetry } from './should-retry.js'\nimport { CircuitBreaker } from './circuit.js'\nimport {\n  TimeoutError,\n  CircuitOpenError,\n  AbortError,\n  RetryLimitError,\n  NetworkError,\n} from './error.js'\n\nexport function createClient(opts: FFetchOptions = {}): FFetch {\n  const {\n    timeout: clientDefaultTimeout = 5_000,\n    retries: clientDefaultRetries = 0,\n    retryDelay: clientDefaultRetryDelay = defaultDelay,\n    shouldRetry: clientDefaultShouldRetry = defaultShouldRetry,\n    hooks: clientDefaultHooks = {},\n    circuit: clientDefaultCircuit,\n    fetchHandler,\n  } = opts\n\n  const breaker = clientDefaultCircuit\n    ? new CircuitBreaker(\n        clientDefaultCircuit.threshold,\n        clientDefaultCircuit.reset\n      )\n    : null\n\n  if (\n    breaker &&\n    (clientDefaultHooks.onCircuitClose || clientDefaultHooks.onCircuitOpen)\n  ) {\n    breaker.setHooks({\n      onCircuitClose: clientDefaultHooks.onCircuitClose,\n      onCircuitOpen: clientDefaultHooks.onCircuitOpen,\n    })\n  }\n\n  const pendingRequests: PendingRequest[] = []\n\n  // Helper to abort all pending requests\n  function abortAll() {\n    for (const entry of pendingRequests) {\n      entry.controller?.abort()\n    }\n  }\n\n  const client = async (\n    input: RequestInfo | URL,\n    init: FFetchRequestInit = {}\n  ) => {\n    // No longer require AbortSignal.timeout - we'll implement it manually if needed\n    let request = new Request(input, init)\n\n    // Merge hooks: per-request hooks override client hooks, but fallback to client hooks\n    const effectiveHooks = { ...clientDefaultHooks, ...(init.hooks || {}) }\n    if (effectiveHooks.transformRequest) {\n      request = await effectiveHooks.transformRequest(request)\n    }\n    await effectiveHooks.before?.(request)\n\n    // Create timeout signal (manual implementation if AbortSignal.timeout not available)\n    function createTimeoutSignal(timeout: number): AbortSignal {\n      if (typeof AbortSignal?.timeout === 'function') {\n        return AbortSignal.timeout(timeout)\n      }\n\n      // Manual implementation for older environments\n      const controller = new AbortController()\n      const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n      // Clean up timeout if signal is aborted early by other means\n      controller.signal.addEventListener(\n        'abort',\n        () => clearTimeout(timeoutId),\n        { once: true }\n      )\n\n      return controller.signal\n    }\n\n    // AbortSignal.timeout/any logic ---\n    const effectiveTimeout = init.timeout ?? clientDefaultTimeout\n    const userSignal = init.signal\n    const transformedSignal = request.signal // Extract signal from transformed request\n    let timeoutSignal: AbortSignal | undefined = undefined\n    let combinedSignal: AbortSignal | undefined = undefined\n    let controller: AbortController | undefined = undefined\n\n    if (effectiveTimeout > 0) {\n      timeoutSignal = createTimeoutSignal(effectiveTimeout)\n    }\n\n    // Collect all signals that need to be combined\n    const signals: AbortSignal[] = []\n    if (userSignal) signals.push(userSignal)\n    if (transformedSignal && transformedSignal !== userSignal) {\n      signals.push(transformedSignal)\n    }\n    if (timeoutSignal) signals.push(timeoutSignal)\n\n    // Use AbortSignal.any for signal combination. Requires native support or a polyfill.\n    // If not available, instruct users to install a polyfill for environments lacking AbortSignal.any.\n    // there are always 1 or more signals\n    if (signals.length === 1) {\n      combinedSignal = signals[0]\n      controller = new AbortController()\n    } else {\n      if (typeof AbortSignal.any !== 'function') {\n        throw new Error(\n          'AbortSignal.any is required for combining multiple signals. Please install a polyfill for environments that do not support it.'\n        )\n      }\n      combinedSignal = AbortSignal.any(signals)\n      controller = new AbortController()\n    }\n    const retryWithHooks = async () => {\n      const effectiveRetries = init.retries ?? clientDefaultRetries\n      const effectiveRetryDelay =\n        typeof init.retryDelay !== 'undefined'\n          ? init.retryDelay\n          : clientDefaultRetryDelay\n      const effectiveShouldRetry = init.shouldRetry ?? clientDefaultShouldRetry\n\n      // Wrap shouldRetry to call onRetry hook\n      let attempt = 0\n      const shouldRetryWithHook = (ctx: import('./types').RetryContext) => {\n        attempt = ctx.attempt\n        const retrying = effectiveShouldRetry(ctx)\n        if (retrying && attempt <= effectiveRetries) {\n          effectiveHooks.onRetry?.(\n            request,\n            attempt - 1,\n            ctx.error,\n            ctx.response\n          )\n        }\n        return retrying\n      }\n\n      function mapToCustomError(err: unknown): unknown {\n        if (err instanceof DOMException && err.name === 'AbortError') {\n          if (timeoutSignal?.aborted && (!userSignal || !userSignal.aborted)) {\n            return new TimeoutError('signal timed out', err)\n          } else {\n            return new AbortError('Request was aborted', err)\n          }\n        } else if (\n          err instanceof TypeError &&\n          /NetworkError|network error|failed to fetch|lost connection|NetworkError when attempting to fetch resource/i.test(\n            err.message\n          )\n        ) {\n          return new NetworkError(err.message, err)\n        }\n        return err\n      }\n\n      async function handleError(err: unknown): Promise<never> {\n        err = mapToCustomError(err)\n        // If user aborted, always throw AbortError, not RetryLimitError\n        if (userSignal?.aborted) {\n          const abortErr = new AbortError('Request was aborted by user')\n          await effectiveHooks.onAbort?.(request)\n          await effectiveHooks.onError?.(request, abortErr)\n          await effectiveHooks.onComplete?.(request, undefined, abortErr)\n          throw abortErr\n        }\n        // If the error is a custom error, re-throw it directly (do not wrap)\n        if (\n          err instanceof TimeoutError ||\n          err instanceof NetworkError ||\n          err instanceof AbortError\n        ) {\n          if (err instanceof TimeoutError) {\n            await effectiveHooks.onTimeout?.(request)\n          }\n          if (err instanceof AbortError) {\n            await effectiveHooks.onAbort?.(request)\n          }\n          await effectiveHooks.onError?.(request, err)\n          await effectiveHooks.onComplete?.(request, undefined, err)\n          throw err\n        }\n        // Otherwise, throw RetryLimitError after all retries are exhausted\n        const retryErr = new RetryLimitError(\n          typeof err === 'object' &&\n          err &&\n          'message' in err &&\n          typeof (err as { message?: unknown }).message === 'string'\n            ? (err as { message: string }).message\n            : 'Retry limit reached'\n        )\n        await effectiveHooks.onError?.(request, retryErr)\n        await effectiveHooks.onComplete?.(request, undefined, retryErr)\n        throw retryErr\n      }\n\n      try {\n        let res = await retry(\n          async () => {\n            // Use AbortSignal.throwIfAborted() before starting fetch\n            if (typeof combinedSignal?.throwIfAborted === 'function') {\n              combinedSignal.throwIfAborted()\n            } else if (combinedSignal?.aborted) {\n              throw new AbortError('Request was aborted')\n            }\n            const reqWithSignal = new Request(request, {\n              signal: combinedSignal,\n            })\n            try {\n              const handler = fetchHandler ?? fetch\n              const response = await handler(reqWithSignal)\n              // Circuit breaker: record result\n              if (breaker) {\n                if (breaker.recordResult(response, undefined, request)) {\n                  throw new Error(`HTTP error: ${response.status}`)\n                }\n              }\n              return response\n            } catch (err) {\n              if (breaker) breaker.recordResult(undefined, err, request)\n              throw mapToCustomError(err)\n            }\n          },\n          effectiveRetries,\n          effectiveRetryDelay,\n          shouldRetryWithHook,\n          request\n        )\n        if (effectiveHooks.transformResponse) {\n          res = await effectiveHooks.transformResponse(res, request)\n        }\n        await effectiveHooks.after?.(request, res)\n        await effectiveHooks.onComplete?.(request, res, undefined)\n        return res\n      } catch (err: unknown) {\n        await handleError(err)\n        throw new Error('Unreachable: handleError should always throw')\n      }\n    }\n\n    const promise = breaker\n      ? breaker.invoke(retryWithHooks).catch(async (err: unknown) => {\n          if (err instanceof CircuitOpenError) {\n            await effectiveHooks.onCircuitOpen?.(request)\n            await effectiveHooks.onError?.(request, err)\n            await effectiveHooks.onComplete?.(request, undefined, err)\n          } else {\n            await effectiveHooks.onError?.(request, err)\n            await effectiveHooks.onComplete?.(request, undefined, err)\n          }\n          throw err\n        })\n      : retryWithHooks()\n\n    const entry: PendingRequest = {\n      promise,\n      request,\n      controller,\n    }\n    pendingRequests.push(entry)\n\n    return promise.finally(() => {\n      const index = pendingRequests.indexOf(entry)\n      if (index > -1) {\n        pendingRequests.splice(index, 1)\n      }\n    })\n  }\n\n  // Add pendingRequests property to the client function (read-only)\n  Object.defineProperty(client, 'pendingRequests', {\n    get() {\n      return pendingRequests\n    },\n    enumerable: false,\n    configurable: false,\n  })\n\n  // Add abortAll method to the client function (read-only)\n  Object.defineProperty(client, 'abortAll', {\n    value: abortAll,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  })\n\n  // Expose circuit breaker open state\n  Object.defineProperty(client, 'circuitOpen', {\n    get() {\n      return breaker ? breaker.open : false\n    },\n    enumerable: true,\n  })\n\n  return client as FFetch\n}\n"],"mappings":"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","names":["shouldRetry","controller"]}