AbortSignal.any polyfill removed

Author: gkoos

README.md

@@ -122,14 +122,21 @@ try {
 
 `ffetch` requires modern AbortSignal APIs:
 
-- **Node.js 18.8+** (or polyfill for older versions)
-- **Modern browsers** (Chrome 88+, Firefox 89+, Safari 15.4+, Edge 88+)
+- **Node.js 20.6+** (for AbortSignal.any)
+- **Modern browsers** (Chrome 117+, Firefox 117+, Safari 17+, Edge 117+)
 
-For older environments, see the [compatibility guide](./docs/compatibility.md).
+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

docs/advanced.md

@@ -44,9 +44,7 @@ Pending requests and abort logic work identically whether you use the default gl
 
 Every `PendingRequest` always has a `controller` property, even if you did not supply an AbortController. This allows you to abort any pending request programmatically, regardless of how it was created.
 
-When multiple signals (user, timeout, transformRequest) are combined and `AbortSignal.any` is not available, ffetch creates a new internal `AbortController` to manage aborts. This controller is always available in `PendingRequest.controller`.
-
-You can always abort a pending request using `pendingRequest.controller.abort()`, even if you did not provide a controller or signal. This works for all requests tracked in `pendingRequests`.
+Signal combination (user, timeout, transformRequest) requires `AbortSignal.any`. If your environment does not support it, you must install a polyfill before using ffetch.
 
 You can access and monitor all active requests through the `pendingRequests` property on the client instance:
 

docs/api.md

@@ -82,6 +82,7 @@ client.abortAll(): void // Aborts all currently pending requests
 
 ### Notes
 
+- Signal combination (user, timeout, transformRequest) requires `AbortSignal.any`. If your environment does not support it, you must install a polyfill before using ffetch.
 - The first retry attempt uses `attempt = 2` (i.e., the first call is attempt 1, first retry is 2)
 - `shouldRetry` default logic: retries on network errors, HTTP 5xx, or 429; does not retry on 4xx (except 429), abort, or timeout errors
 - All client options can be overridden on a per-request basis via the `init` parameter

docs/compatibility.md

@@ -2,7 +2,7 @@
 
 ## Prerequisites
 
-`ffetch` requires modern AbortSignal APIs, specifically `AbortSignal.timeout` and `AbortSignal.any`.
+`ffetch` requires modern AbortSignal APIs, specifically `AbortSignal.timeout` and **AbortSignal.any**. Signal combination requires `AbortSignal.any` (native or polyfill).
 
 ## Node.js Support
 
@@ -13,21 +13,19 @@
 
 ### Polyfills for Older Versions
 
-For older Node.js versions, you must install a polyfill:
+For older Node.js versions, you must install a polyfill for both `AbortSignal.timeout` and `AbortSignal.any`:
 
 ```bash
-npm install abortcontroller-polyfill
-# or
-npm install abort-controller-x
+npm install abortcontroller-polyfill abort-controller-x
 ```
 
 Then ensure the APIs are available globally before importing `ffetch`:
 
 ```javascript
-// Option 1: abortcontroller-polyfill
+// Option 1: abortcontroller-polyfill (for AbortSignal.timeout)
 require('abortcontroller-polyfill/dist/polyfill-patch-fetch')
 
-// Option 2: abort-controller-x
+// Option 2: abort-controller-x (for AbortSignal.any)
 import 'abort-controller-x/polyfill'
 
 // Now you can use ffetch
@@ -209,7 +207,9 @@ function checkCompatibility() {
   }
 
   if (typeof AbortSignal.any !== 'function') {
-    console.warn('AbortSignal.any not supported. Some features may not work.')
+    throw new Error(
+      'AbortSignal.any is required for combining multiple signals. Please install a polyfill.'
+    )
   }
 }
 

docs/migration.md

@@ -299,13 +299,15 @@ const client = createClient({
 const controller = new AbortController()
 const response = await fetch(url, { signal: controller.signal })
 
-// ffetch - combines multiple signals automatically
+// ffetch - combines multiple signals automatically using AbortSignal.any
+// Requires AbortSignal.any (native or polyfill)
 const controller = new AbortController()
 const response = await client(url, {
   signal: controller.signal, // User signal
   timeout: 5000, // Creates timeout signal
   // Both signals are automatically combined
 })
+// If AbortSignal.any is not available, you must install a polyfill before using ffetch
 ```
 
 ### 2. **Error Instance Checks**

src/client.ts

@@ -96,35 +96,22 @@ export function createClient(opts: FFetchOptions = {}): FFetch {
     }
     if (timeoutSignal) signals.push(timeoutSignal)
 
+    // Use AbortSignal.any for signal combination. Requires native support or a polyfill.
+    // If not available, instruct users to install a polyfill for environments lacking AbortSignal.any.
     if (signals.length === 0) {
       combinedSignal = undefined
+      controller = new AbortController()
     } else if (signals.length === 1) {
       combinedSignal = signals[0]
-      // Always create a new AbortController for tracking
       controller = new AbortController()
     } else {
-      // Multiple signals need to be combined
-      if (typeof AbortSignal.any === 'function') {
-        combinedSignal = AbortSignal.any(signals)
-        controller = new AbortController()
-      } else {
-        // Manual fallback: create a controller that aborts when any signal aborts
-        controller = new AbortController()
-        combinedSignal = controller.signal
-
-        // If any signal is already aborted, abort immediately
-        if (signals.some((signal) => signal.aborted)) {
-          controller.abort()
-        } else {
-          // Listen for abort events on all signals
-          const abortHandler = () => {
-            if (controller) controller.abort()
-          }
-          signals.forEach((signal) => {
-            signal.addEventListener('abort', abortHandler, { once: true })
-          })
-        }
+      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

test/client.abort-fallback.test.ts

@@ -240,22 +240,4 @@ describe('Advanced/Edge Cases: Custom Errors', () => {
       expect(err.message).toBe('Retry limit reached')
     }
   })
-
-  it('throws AbortError if combinedSignal.aborted is true and throwIfAborted is missing', async () => {
-    // Remove AbortSignal.any to force fallback branch
-    const origAny = AbortSignal.any
-    // @ts-expect-error: Simulate missing AbortSignal.any for fallback branch coverage
-    AbortSignal.any = undefined
-
-    // Use a minimal fake signal for branch coverage; cast to AbortSignal for test only
-    const fakeSignal = { aborted: true } as unknown as AbortSignal
-
-    const f = createClient()
-    await expect(
-      f('https://example.com', { signal: fakeSignal })
-    ).rejects.toThrowError(new AbortError('Request was aborted by user'))
-
-    // Restore AbortSignal.any
-    AbortSignal.any = origAny
-  })
 })