@trpc/client 11.0.0-alpha-tmp-subscription-connection-state.488 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/links/httpSubscriptionLink.js

@@ -1,7 +1,10 @@
 'use strict';
 
 var observable = require('@trpc/server/observable');
+var rpc = require('@trpc/server/rpc');
 var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
+var inputWithTrackedEventId = require('../internals/inputWithTrackedEventId.js');
+var signals = require('../internals/signals.js');
 var TRPCClientError = require('../TRPCClientError.js');
 var transformer = require('../internals/transformer.js');
 var httpUtils = require('./internals/httpUtils.js');
@@ -16,89 +19,142 @@ async function urlWithConnectionParams(opts) {
     }
     return url;
 }
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */ const codes5xx = [
+    rpc.TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+    rpc.TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+    rpc.TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+    rpc.TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
 /**
  * @see https://trpc.io/docs/client/links/httpSubscriptionLink
  */ function unstable_httpSubscriptionLink(opts) {
     const transformer$1 = transformer.getTransformer(opts.transformer);
     return ()=>{
-        return ({ op  })=>{
+        return ({ op })=>{
             return observable.observable((observer)=>{
-                const { type , path , input  } = op;
+                const { type, path, input } = op;
                 /* istanbul ignore if -- @preserve */ if (type !== 'subscription') {
                     throw new Error('httpSubscriptionLink only supports subscriptions');
                 }
-                let eventSource = null;
-                let unsubscribed = false;
-                unstableCoreDoNotImport.run(async ()=>{
-                    const url = httpUtils.getUrl({
-                        transformer: transformer$1,
-                        url: await urlWithConnectionParams(opts),
-                        input,
-                        path,
-                        type,
-                        signal: null
-                    });
-                    const eventSourceOptions = await urlWithConnectionParams$1.resultOf(opts.eventSourceOptions);
-                    /* istanbul ignore if -- @preserve */ if (unsubscribed) {
-                        // already unsubscribed - rare race condition
-                        return;
-                    }
-                    eventSource = new EventSource(url, eventSourceOptions);
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'connecting',
-                            data: null
-                        }
-                    });
-                    const onStarted = ()=>{
-                        observer.next({
-                            result: {
-                                type: 'started'
-                            },
-                            context: {
-                                eventSource
-                            }
-                        });
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        eventSource.removeEventListener('open', onStarted);
-                    };
-                    // console.log('starting', new Date());
-                    eventSource.addEventListener('open', onStarted);
-                    eventSource.addEventListener('open', ()=>{
+                let lastEventId = undefined;
+                const ac = new AbortController();
+                const signal = signals.raceAbortSignals(op.signal, ac.signal);
+                const eventSourceStream = unstableCoreDoNotImport.sseStreamConsumer({
+                    url: async ()=>httpUtils.getUrl({
+                            transformer: transformer$1,
+                            url: await urlWithConnectionParams(opts),
+                            input: inputWithTrackedEventId.inputWithTrackedEventId(input, lastEventId),
+                            path,
+                            type,
+                            signal: null
+                        }),
+                    init: ()=>urlWithConnectionParams$1.resultOf(opts.eventSourceOptions, {
+                            op
+                        }),
+                    signal,
+                    deserialize: transformer$1.output.deserialize,
+                    EventSource: opts.EventSource ?? globalThis.EventSource
+                });
+                const connectionState = observable.behaviorSubject({
+                    type: 'state',
+                    state: 'connecting',
+                    error: null
+                });
+                const connectionSub = connectionState.subscribe({
+                    next (state) {
                         observer.next({
-                            result: {
-                                type: 'state',
-                                state: 'pending'
-                            }
+                            result: state
                         });
-                    });
-                    eventSource.addEventListener('error', (event)=>{
-                        // sseStreamConsumer handles this already
-                        if (eventSource?.readyState === EventSource.CLOSED) {
-                            return;
+                    }
+                });
+                unstableCoreDoNotImport.run(async ()=>{
+                    for await (const chunk of eventSourceStream){
+                        switch(chunk.type){
+                            case 'ping':
+                                break;
+                            case 'data':
+                                const chunkData = chunk.data;
+                                let result;
+                                if (chunkData.id) {
+                                    // if the `tracked()`-helper is used, we always have an `id` field
+                                    lastEventId = chunkData.id;
+                                    result = {
+                                        id: chunkData.id,
+                                        data: chunkData
+                                    };
+                                } else {
+                                    result = {
+                                        data: chunkData.data
+                                    };
+                                }
+                                observer.next({
+                                    result,
+                                    context: {
+                                        eventSource: chunk.eventSource
+                                    }
+                                });
+                                break;
+                            case 'connected':
+                                {
+                                    observer.next({
+                                        result: {
+                                            type: 'started'
+                                        },
+                                        context: {
+                                            eventSource: chunk.eventSource
+                                        }
+                                    });
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'pending',
+                                        error: null
+                                    });
+                                    break;
+                                }
+                            case 'serialized-error':
+                                {
+                                    const error = TRPCClientError.TRPCClientError.from({
+                                        error: chunk.error
+                                    });
+                                    if (codes5xx.includes(chunk.error.code)) {
+                                        //
+                                        connectionState.next({
+                                            type: 'state',
+                                            state: 'connecting',
+                                            error
+                                        });
+                                        break;
+                                    }
+                                    //
+                                    // non-retryable error, cancel the subscription
+                                    throw error;
+                                }
+                            case 'connecting':
+                                {
+                                    const lastState = connectionState.get();
+                                    const error = chunk.event && TRPCClientError.TRPCClientError.from(chunk.event);
+                                    if (!error && lastState.state === 'connecting') {
+                                        break;
+                                    }
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'connecting',
+                                        error
+                                    });
+                                    break;
+                                }
+                            case 'timeout':
+                                {
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'connecting',
+                                        error: new TRPCClientError.TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
+                                    });
+                                }
                         }
-                        const error = globalThis.ErrorEvent && event instanceof ErrorEvent ? TRPCClientError.TRPCClientError.from(event.error) : TRPCClientError.TRPCClientError.from(new Error(`Unknown EventSource error`));
-                        observer.next({
-                            result: {
-                                type: 'state',
-                                state: 'connecting',
-                                data: error
-                            }
-                        });
-                    });
-                    const iterable = unstableCoreDoNotImport.sseStreamConsumer({
-                        from: eventSource,
-                        deserialize: transformer$1.output.deserialize
-                    });
-                    for await (const chunk of iterable){
-                        // if the `sse({})`-helper is used, we always have an `id` field
-                        const data = 'id' in chunk ? chunk : chunk.data;
-                        observer.next({
-                            result: {
-                                data
-                            }
-                        });
                     }
                     observer.next({
                         result: {
@@ -106,33 +162,13 @@ async function urlWithConnectionParams(opts) {
                         }
                     });
                     observer.complete();
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'idle'
-                        }
-                    });
                 }).catch((error)=>{
-                    const trpcError = TRPCClientError.TRPCClientError.from(error);
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'error',
-                            data: TRPCClientError.TRPCClientError.from(trpcError)
-                        }
-                    });
-                    observer.error(trpcError);
+                    observer.error(TRPCClientError.TRPCClientError.from(error));
                 });
                 return ()=>{
                     observer.complete();
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'idle'
-                        }
-                    });
-                    eventSource?.close();
-                    unsubscribed = true;
+                    ac.abort();
+                    connectionSub.unsubscribe();
                 };
             });
         };

package/dist/links/httpSubscriptionLink.mjs

@@ -1,5 +1,8 @@
-import { observable } from '@trpc/server/observable';
-import { run, sseStreamConsumer } from '@trpc/server/unstable-core-do-not-import';
+import { observable, behaviorSubject } from '@trpc/server/observable';
+import { TRPC_ERROR_CODES_BY_KEY } from '@trpc/server/rpc';
+import { sseStreamConsumer, run } from '@trpc/server/unstable-core-do-not-import';
+import { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId.mjs';
+import { raceAbortSignals } from '../internals/signals.mjs';
 import { TRPCClientError } from '../TRPCClientError.mjs';
 import { getTransformer } from '../internals/transformer.mjs';
 import { getUrl } from './internals/httpUtils.mjs';
@@ -14,89 +17,142 @@ async function urlWithConnectionParams(opts) {
     }
     return url;
 }
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */ const codes5xx = [
+    TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+    TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+    TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+    TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
 /**
  * @see https://trpc.io/docs/client/links/httpSubscriptionLink
  */ function unstable_httpSubscriptionLink(opts) {
     const transformer = getTransformer(opts.transformer);
     return ()=>{
-        return ({ op  })=>{
+        return ({ op })=>{
             return observable((observer)=>{
-                const { type , path , input  } = op;
+                const { type, path, input } = op;
                 /* istanbul ignore if -- @preserve */ if (type !== 'subscription') {
                     throw new Error('httpSubscriptionLink only supports subscriptions');
                 }
-                let eventSource = null;
-                let unsubscribed = false;
-                run(async ()=>{
-                    const url = getUrl({
-                        transformer,
-                        url: await urlWithConnectionParams(opts),
-                        input,
-                        path,
-                        type,
-                        signal: null
-                    });
-                    const eventSourceOptions = await resultOf(opts.eventSourceOptions);
-                    /* istanbul ignore if -- @preserve */ if (unsubscribed) {
-                        // already unsubscribed - rare race condition
-                        return;
-                    }
-                    eventSource = new EventSource(url, eventSourceOptions);
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'connecting',
-                            data: null
-                        }
-                    });
-                    const onStarted = ()=>{
-                        observer.next({
-                            result: {
-                                type: 'started'
-                            },
-                            context: {
-                                eventSource
-                            }
-                        });
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        eventSource.removeEventListener('open', onStarted);
-                    };
-                    // console.log('starting', new Date());
-                    eventSource.addEventListener('open', onStarted);
-                    eventSource.addEventListener('open', ()=>{
+                let lastEventId = undefined;
+                const ac = new AbortController();
+                const signal = raceAbortSignals(op.signal, ac.signal);
+                const eventSourceStream = sseStreamConsumer({
+                    url: async ()=>getUrl({
+                            transformer,
+                            url: await urlWithConnectionParams(opts),
+                            input: inputWithTrackedEventId(input, lastEventId),
+                            path,
+                            type,
+                            signal: null
+                        }),
+                    init: ()=>resultOf(opts.eventSourceOptions, {
+                            op
+                        }),
+                    signal,
+                    deserialize: transformer.output.deserialize,
+                    EventSource: opts.EventSource ?? globalThis.EventSource
+                });
+                const connectionState = behaviorSubject({
+                    type: 'state',
+                    state: 'connecting',
+                    error: null
+                });
+                const connectionSub = connectionState.subscribe({
+                    next (state) {
                         observer.next({
-                            result: {
-                                type: 'state',
-                                state: 'pending'
-                            }
+                            result: state
                         });
-                    });
-                    eventSource.addEventListener('error', (event)=>{
-                        // sseStreamConsumer handles this already
-                        if (eventSource?.readyState === EventSource.CLOSED) {
-                            return;
+                    }
+                });
+                run(async ()=>{
+                    for await (const chunk of eventSourceStream){
+                        switch(chunk.type){
+                            case 'ping':
+                                break;
+                            case 'data':
+                                const chunkData = chunk.data;
+                                let result;
+                                if (chunkData.id) {
+                                    // if the `tracked()`-helper is used, we always have an `id` field
+                                    lastEventId = chunkData.id;
+                                    result = {
+                                        id: chunkData.id,
+                                        data: chunkData
+                                    };
+                                } else {
+                                    result = {
+                                        data: chunkData.data
+                                    };
+                                }
+                                observer.next({
+                                    result,
+                                    context: {
+                                        eventSource: chunk.eventSource
+                                    }
+                                });
+                                break;
+                            case 'connected':
+                                {
+                                    observer.next({
+                                        result: {
+                                            type: 'started'
+                                        },
+                                        context: {
+                                            eventSource: chunk.eventSource
+                                        }
+                                    });
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'pending',
+                                        error: null
+                                    });
+                                    break;
+                                }
+                            case 'serialized-error':
+                                {
+                                    const error = TRPCClientError.from({
+                                        error: chunk.error
+                                    });
+                                    if (codes5xx.includes(chunk.error.code)) {
+                                        //
+                                        connectionState.next({
+                                            type: 'state',
+                                            state: 'connecting',
+                                            error
+                                        });
+                                        break;
+                                    }
+                                    //
+                                    // non-retryable error, cancel the subscription
+                                    throw error;
+                                }
+                            case 'connecting':
+                                {
+                                    const lastState = connectionState.get();
+                                    const error = chunk.event && TRPCClientError.from(chunk.event);
+                                    if (!error && lastState.state === 'connecting') {
+                                        break;
+                                    }
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'connecting',
+                                        error
+                                    });
+                                    break;
+                                }
+                            case 'timeout':
+                                {
+                                    connectionState.next({
+                                        type: 'state',
+                                        state: 'connecting',
+                                        error: new TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
+                                    });
+                                }
                         }
-                        const error = globalThis.ErrorEvent && event instanceof ErrorEvent ? TRPCClientError.from(event.error) : TRPCClientError.from(new Error(`Unknown EventSource error`));
-                        observer.next({
-                            result: {
-                                type: 'state',
-                                state: 'connecting',
-                                data: error
-                            }
-                        });
-                    });
-                    const iterable = sseStreamConsumer({
-                        from: eventSource,
-                        deserialize: transformer.output.deserialize
-                    });
-                    for await (const chunk of iterable){
-                        // if the `sse({})`-helper is used, we always have an `id` field
-                        const data = 'id' in chunk ? chunk : chunk.data;
-                        observer.next({
-                            result: {
-                                data
-                            }
-                        });
                     }
                     observer.next({
                         result: {
@@ -104,33 +160,13 @@ async function urlWithConnectionParams(opts) {
                         }
                     });
                     observer.complete();
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'idle'
-                        }
-                    });
                 }).catch((error)=>{
-                    const trpcError = TRPCClientError.from(error);
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'error',
-                            data: TRPCClientError.from(trpcError)
-                        }
-                    });
-                    observer.error(trpcError);
+                    observer.error(TRPCClientError.from(error));
                 });
                 return ()=>{
                     observer.complete();
-                    observer.next({
-                        result: {
-                            type: 'state',
-                            state: 'idle'
-                        }
-                    });
-                    eventSource?.close();
-                    unsubscribed = true;
+                    ac.abort();
+                    connectionSub.unsubscribe();
                 };
             });
         };

package/dist/links/internals/contentTypes.d.ts

@@ -1,4 +1,4 @@
-export declare function isOctetType(input: unknown): input is Uint8Array | Blob;
+export declare function isOctetType(input: unknown): input is Uint8Array<ArrayBufferLike> | Blob;
 export declare function isFormData(input: unknown): input is FormData;
-export declare function isNonJsonSerializable(input: unknown): input is Uint8Array | Blob | FormData;
+export declare function isNonJsonSerializable(input: unknown): input is FormData | Uint8Array<ArrayBufferLike> | Blob;
 //# sourceMappingURL=contentTypes.d.ts.map

package/dist/links/internals/contentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentTypes.d.ts","sourceRoot":"","sources":["../../../src/links/internals/contentTypes.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,8BAMzC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,qBAExC;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,yCAEnD"}
+{"version":3,"file":"contentTypes.d.ts","sourceRoot":"","sources":["../../../src/links/internals/contentTypes.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,+CAMzC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,qBAExC;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,0DAEnD"}

package/dist/links/internals/httpUtils.d.ts

@@ -14,7 +14,7 @@ export type HTTPLinkBaseOptions<TRoot extends Pick<AnyClientTypes, 'transformer'
     /**
      * Send all requests `as POST`s requests regardless of the procedure type
      * The HTTP handler must separately allow overriding the method. See:
-     * @link https://trpc.io/docs/rpc
+     * @see https://trpc.io/docs/rpc
      */
     methodOverride?: 'POST';
 } & TransformerOptions<TRoot>;
@@ -64,12 +64,5 @@ export type HTTPRequestOptions = ContentOptions & HTTPBaseRequestOptions & {
 };
 export declare function fetchHTTPResponse(opts: HTTPRequestOptions): Promise<ResponseEsque>;
 export declare function httpRequest(opts: HTTPRequestOptions): Promise<HTTPResult>;
-/**
- * Merges multiple abort signals into a single one
- * - When all signals have been aborted, the merged signal will be aborted
- */
-export declare function mergeAbortSignals(opts: {
-    signal: Maybe<AbortSignal>;
-}[]): AbortController;
 export {};
 //# sourceMappingURL=httpUtils.d.ts.map

package/dist/links/internals/httpUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpUtils.d.ts","sourceRoot":"","sources":["../../../src/links/internals/httpUtils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"httpUtils.d.ts","sourceRoot":"","sources":["../../../src/links/internals/httpUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACvB,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,EACb,MAAM,0CAA0C,CAAC;AAElD,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAC7B,KAAK,SAAS,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,IAC/C;IACF,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAClB;;OAEG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;AAE9B,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,uBAAuB,CAAC;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,mBAAmB,CAAC,cAAc,CAAC,GACxC,uBAAuB,CAOzB;AAkBD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE;QACJ,QAAQ,EAAE,aAAa,CAAC;QACxB,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,CAAC;CACH;AAED,KAAK,eAAe,GAAG;IACrB,WAAW,EAAE,uBAAuB,CAAC;CACtC,GAAG,CAAC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC,CAAC;AAEjD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,eAAe,OAM7C;AAED,MAAM,MAAM,sBAAsB,GAAG,eAAe,GAClD,uBAAuB,GAAG;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC5B,CAAC;AAEJ,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,sBAAsB,KAAK,MAAM,CAAC;AACvD,KAAK,OAAO,GAAG,CAAC,IAAI,EAAE,sBAAsB,KAAK,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAuBpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,OAMrB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,CACtB,IAAI,EAAE,sBAAsB,GAAG;IAC7B,OAAO,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACnD,KACE,OAAO,CAAC,UAAU,CAAC,CAAC;AAEzB,eAAO,MAAM,iBAAiB,EAAE,SAO/B,CAAC;AAcF,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAC7C,sBAAsB,GAAG;IACvB,OAAO,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACnD,CAAC;AAuBJ,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,0BA6B/D;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,UAAU,CAAC,CAcrB"}

package/dist/links/internals/httpUtils.js

@@ -96,7 +96,7 @@ async function fetchHTTPResponse(opts) {
     throwIfAborted(opts.signal);
     const url = opts.getUrl(opts);
     const body = opts.getBody(opts);
-    const { type  } = opts;
+    const { type } = opts;
     const resolvedHeaders = await (async ()=>{
         const heads = await opts.headers();
         if (Symbol.iterator in heads) {
@@ -131,34 +131,6 @@ async function httpRequest(opts) {
         meta
     };
 }
-/**
- * Merges multiple abort signals into a single one
- * - When all signals have been aborted, the merged signal will be aborted
- */ function mergeAbortSignals(opts) {
-    const ac = new AbortController();
-    if (opts.some((o)=>!o.signal)) {
-        return ac;
-    }
-    const count = opts.length;
-    let abortedCount = 0;
-    const onAbort = ()=>{
-        if (++abortedCount === count) {
-            ac.abort();
-        }
-    };
-    for (const o of opts){
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const signal = o.signal;
-        if (signal.aborted) {
-            onAbort();
-        } else {
-            signal.addEventListener('abort', onAbort, {
-                once: true
-            });
-        }
-    }
-    return ac;
-}
 
 exports.fetchHTTPResponse = fetchHTTPResponse;
 exports.getBody = getBody;
@@ -166,5 +138,4 @@ exports.getInput = getInput;
 exports.getUrl = getUrl;
 exports.httpRequest = httpRequest;
 exports.jsonHttpRequester = jsonHttpRequester;
-exports.mergeAbortSignals = mergeAbortSignals;
 exports.resolveHTTPLinkOptions = resolveHTTPLinkOptions;