@trpc/client 11.3.1-canary.1 → 11.3.2-canary.2

package/dist/links/httpBatchStreamLink.js

@@ -1,150 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
-var dataLoader = require('../internals/dataLoader.js');
-var signals = require('../internals/signals.js');
-var TRPCClientError = require('../TRPCClientError.js');
-var httpUtils = require('./internals/httpUtils.js');
-
-/**
- * @see https://trpc.io/docs/client/links/httpBatchStreamLink
- */ function httpBatchStreamLink(opts) {
-    const resolvedOpts = httpUtils.resolveHTTPLinkOptions(opts);
-    const maxURLLength = opts.maxURLLength ?? Infinity;
-    const maxItems = opts.maxItems ?? Infinity;
-    return ()=>{
-        const batchLoader = (type)=>{
-            return {
-                validate (batchOps) {
-                    if (maxURLLength === Infinity && maxItems === Infinity) {
-                        // escape hatch for quick calcs
-                        return true;
-                    }
-                    if (batchOps.length > maxItems) {
-                        return false;
-                    }
-                    const path = batchOps.map((op)=>op.path).join(',');
-                    const inputs = batchOps.map((op)=>op.input);
-                    const url = httpUtils.getUrl({
-                        ...resolvedOpts,
-                        type,
-                        path,
-                        inputs,
-                        signal: null
-                    });
-                    return url.length <= maxURLLength;
-                },
-                async fetch (batchOps) {
-                    const path = batchOps.map((op)=>op.path).join(',');
-                    const inputs = batchOps.map((op)=>op.input);
-                    const batchSignals = signals.allAbortSignals(...batchOps.map((op)=>op.signal));
-                    const abortController = new AbortController();
-                    const responsePromise = httpUtils.fetchHTTPResponse({
-                        ...resolvedOpts,
-                        signal: signals.raceAbortSignals(batchSignals, abortController.signal),
-                        type,
-                        contentTypeHeader: 'application/json',
-                        trpcAcceptHeader: 'application/jsonl',
-                        getUrl: httpUtils.getUrl,
-                        getBody: httpUtils.getBody,
-                        inputs,
-                        path,
-                        headers () {
-                            if (!opts.headers) {
-                                return {};
-                            }
-                            if (typeof opts.headers === 'function') {
-                                return opts.headers({
-                                    opList: batchOps
-                                });
-                            }
-                            return opts.headers;
-                        }
-                    });
-                    const res = await responsePromise;
-                    const [head] = await unstableCoreDoNotImport.jsonlStreamConsumer({
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        from: res.body,
-                        deserialize: resolvedOpts.transformer.output.deserialize,
-                        // onError: console.error,
-                        formatError (opts) {
-                            const error = opts.error;
-                            return TRPCClientError.TRPCClientError.from({
-                                error
-                            });
-                        },
-                        abortController
-                    });
-                    const promises = Object.keys(batchOps).map(async (key)=>{
-                        let json = await Promise.resolve(head[key]);
-                        if ('result' in json) {
-                            /**
-                 * Not very pretty, but we need to unwrap nested data as promises
-                 * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
-                 */ const result = await Promise.resolve(json.result);
-                            json = {
-                                result: {
-                                    data: await Promise.resolve(result.data)
-                                }
-                            };
-                        }
-                        return {
-                            json,
-                            meta: {
-                                response: res
-                            }
-                        };
-                    });
-                    return promises;
-                }
-            };
-        };
-        const query = dataLoader.dataLoader(batchLoader('query'));
-        const mutation = dataLoader.dataLoader(batchLoader('mutation'));
-        const loaders = {
-            query,
-            mutation
-        };
-        return ({ op })=>{
-            return observable.observable((observer)=>{
-                /* istanbul ignore if -- @preserve */ if (op.type === 'subscription') {
-                    throw new Error('Subscriptions are unsupported by `httpBatchStreamLink` - use `httpSubscriptionLink` or `wsLink`');
-                }
-                const loader = loaders[op.type];
-                const promise = loader.load(op);
-                let _res = undefined;
-                promise.then((res)=>{
-                    _res = res;
-                    if ('error' in res.json) {
-                        observer.error(TRPCClientError.TRPCClientError.from(res.json, {
-                            meta: res.meta
-                        }));
-                        return;
-                    } else if ('result' in res.json) {
-                        observer.next({
-                            context: res.meta,
-                            result: res.json.result
-                        });
-                        observer.complete();
-                        return;
-                    }
-                    observer.complete();
-                }).catch((err)=>{
-                    observer.error(TRPCClientError.TRPCClientError.from(err, {
-                        meta: _res?.meta
-                    }));
-                });
-                return ()=>{
-                // noop
-                };
-            });
-        };
-    };
-}
-/**
- * @deprecated use {@link httpBatchStreamLink} instead
- */ const unstable_httpBatchStreamLink = httpBatchStreamLink;
-
-exports.httpBatchStreamLink = httpBatchStreamLink;
-exports.unstable_httpBatchStreamLink = unstable_httpBatchStreamLink;

package/dist/links/httpBatchStreamLink.mjs

@@ -1,147 +0,0 @@
-import { observable } from '@trpc/server/observable';
-import { jsonlStreamConsumer } from '@trpc/server/unstable-core-do-not-import';
-import { dataLoader } from '../internals/dataLoader.mjs';
-import { allAbortSignals, raceAbortSignals } from '../internals/signals.mjs';
-import { TRPCClientError } from '../TRPCClientError.mjs';
-import { resolveHTTPLinkOptions, fetchHTTPResponse, getBody, getUrl } from './internals/httpUtils.mjs';
-
-/**
- * @see https://trpc.io/docs/client/links/httpBatchStreamLink
- */ function httpBatchStreamLink(opts) {
-    const resolvedOpts = resolveHTTPLinkOptions(opts);
-    const maxURLLength = opts.maxURLLength ?? Infinity;
-    const maxItems = opts.maxItems ?? Infinity;
-    return ()=>{
-        const batchLoader = (type)=>{
-            return {
-                validate (batchOps) {
-                    if (maxURLLength === Infinity && maxItems === Infinity) {
-                        // escape hatch for quick calcs
-                        return true;
-                    }
-                    if (batchOps.length > maxItems) {
-                        return false;
-                    }
-                    const path = batchOps.map((op)=>op.path).join(',');
-                    const inputs = batchOps.map((op)=>op.input);
-                    const url = getUrl({
-                        ...resolvedOpts,
-                        type,
-                        path,
-                        inputs,
-                        signal: null
-                    });
-                    return url.length <= maxURLLength;
-                },
-                async fetch (batchOps) {
-                    const path = batchOps.map((op)=>op.path).join(',');
-                    const inputs = batchOps.map((op)=>op.input);
-                    const batchSignals = allAbortSignals(...batchOps.map((op)=>op.signal));
-                    const abortController = new AbortController();
-                    const responsePromise = fetchHTTPResponse({
-                        ...resolvedOpts,
-                        signal: raceAbortSignals(batchSignals, abortController.signal),
-                        type,
-                        contentTypeHeader: 'application/json',
-                        trpcAcceptHeader: 'application/jsonl',
-                        getUrl,
-                        getBody,
-                        inputs,
-                        path,
-                        headers () {
-                            if (!opts.headers) {
-                                return {};
-                            }
-                            if (typeof opts.headers === 'function') {
-                                return opts.headers({
-                                    opList: batchOps
-                                });
-                            }
-                            return opts.headers;
-                        }
-                    });
-                    const res = await responsePromise;
-                    const [head] = await jsonlStreamConsumer({
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        from: res.body,
-                        deserialize: resolvedOpts.transformer.output.deserialize,
-                        // onError: console.error,
-                        formatError (opts) {
-                            const error = opts.error;
-                            return TRPCClientError.from({
-                                error
-                            });
-                        },
-                        abortController
-                    });
-                    const promises = Object.keys(batchOps).map(async (key)=>{
-                        let json = await Promise.resolve(head[key]);
-                        if ('result' in json) {
-                            /**
-                 * Not very pretty, but we need to unwrap nested data as promises
-                 * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
-                 */ const result = await Promise.resolve(json.result);
-                            json = {
-                                result: {
-                                    data: await Promise.resolve(result.data)
-                                }
-                            };
-                        }
-                        return {
-                            json,
-                            meta: {
-                                response: res
-                            }
-                        };
-                    });
-                    return promises;
-                }
-            };
-        };
-        const query = dataLoader(batchLoader('query'));
-        const mutation = dataLoader(batchLoader('mutation'));
-        const loaders = {
-            query,
-            mutation
-        };
-        return ({ op })=>{
-            return observable((observer)=>{
-                /* istanbul ignore if -- @preserve */ if (op.type === 'subscription') {
-                    throw new Error('Subscriptions are unsupported by `httpBatchStreamLink` - use `httpSubscriptionLink` or `wsLink`');
-                }
-                const loader = loaders[op.type];
-                const promise = loader.load(op);
-                let _res = undefined;
-                promise.then((res)=>{
-                    _res = res;
-                    if ('error' in res.json) {
-                        observer.error(TRPCClientError.from(res.json, {
-                            meta: res.meta
-                        }));
-                        return;
-                    } else if ('result' in res.json) {
-                        observer.next({
-                            context: res.meta,
-                            result: res.json.result
-                        });
-                        observer.complete();
-                        return;
-                    }
-                    observer.complete();
-                }).catch((err)=>{
-                    observer.error(TRPCClientError.from(err, {
-                        meta: _res?.meta
-                    }));
-                });
-                return ()=>{
-                // noop
-                };
-            });
-        };
-    };
-}
-/**
- * @deprecated use {@link httpBatchStreamLink} instead
- */ const unstable_httpBatchStreamLink = httpBatchStreamLink;
-
-export { httpBatchStreamLink, unstable_httpBatchStreamLink };

package/dist/links/httpLink.d.ts

@@ -1,17 +0,0 @@
-import type { AnyClientTypes, AnyRouter } from '@trpc/server/unstable-core-do-not-import';
-import type { HTTPLinkBaseOptions } from './internals/httpUtils';
-import { type HTTPHeaders, type Operation, type TRPCLink } from './types';
-export type HTTPLinkOptions<TRoot extends AnyClientTypes> = HTTPLinkBaseOptions<TRoot> & {
-    /**
-     * Headers to be set on outgoing requests or a callback that of said headers
-     * @see http://trpc.io/docs/client/headers
-     */
-    headers?: HTTPHeaders | ((opts: {
-        op: Operation;
-    }) => HTTPHeaders | Promise<HTTPHeaders>);
-};
-/**
- * @see https://trpc.io/docs/client/links/httpLink
- */
-export declare function httpLink<TRouter extends AnyRouter = AnyRouter>(opts: HTTPLinkOptions<TRouter['_def']['_config']['$types']>): TRPCLink<TRouter>;
-//# sourceMappingURL=httpLink.d.ts.map

package/dist/links/httpLink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpLink.d.ts","sourceRoot":"","sources":["../../src/links/httpLink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACV,MAAM,0CAA0C,CAAC;AAGlD,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,uBAAuB,CAAC;AAO/B,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,cAAc,IACtD,mBAAmB,CAAC,KAAK,CAAC,GAAG;IAC3B;;;OAGG;IACH,OAAO,CAAC,EACJ,WAAW,GACX,CAAC,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;CACvE,CAAC;AAoCJ;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,SAAS,SAAS,GAAG,SAAS,EAC5D,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,GAC1D,QAAQ,CAAC,OAAO,CAAC,CAgEnB"}

package/dist/links/httpLink.js

@@ -1,95 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
-var TRPCClientError = require('../TRPCClientError.js');
-var httpUtils = require('./internals/httpUtils.js');
-var contentTypes = require('./internals/contentTypes.js');
-
-const universalRequester = (opts)=>{
-    if ('input' in opts) {
-        const { input } = opts;
-        if (contentTypes.isFormData(input)) {
-            if (opts.type !== 'mutation' && opts.methodOverride !== 'POST') {
-                throw new Error('FormData is only supported for mutations');
-            }
-            return httpUtils.httpRequest({
-                ...opts,
-                // The browser will set this automatically and include the boundary= in it
-                contentTypeHeader: undefined,
-                getUrl: httpUtils.getUrl,
-                getBody: ()=>input
-            });
-        }
-        if (contentTypes.isOctetType(input)) {
-            if (opts.type !== 'mutation' && opts.methodOverride !== 'POST') {
-                throw new Error('Octet type input is only supported for mutations');
-            }
-            return httpUtils.httpRequest({
-                ...opts,
-                contentTypeHeader: 'application/octet-stream',
-                getUrl: httpUtils.getUrl,
-                getBody: ()=>input
-            });
-        }
-    }
-    return httpUtils.jsonHttpRequester(opts);
-};
-/**
- * @see https://trpc.io/docs/client/links/httpLink
- */ function httpLink(opts) {
-    const resolvedOpts = httpUtils.resolveHTTPLinkOptions(opts);
-    return ()=>{
-        return ({ op })=>{
-            return observable.observable((observer)=>{
-                const { path, input, type } = op;
-                /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
-                    throw new Error('Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`');
-                }
-                const request = universalRequester({
-                    ...resolvedOpts,
-                    type,
-                    path,
-                    input,
-                    signal: op.signal,
-                    headers () {
-                        if (!opts.headers) {
-                            return {};
-                        }
-                        if (typeof opts.headers === 'function') {
-                            return opts.headers({
-                                op
-                            });
-                        }
-                        return opts.headers;
-                    }
-                });
-                let meta = undefined;
-                request.then((res)=>{
-                    meta = res.meta;
-                    const transformed = unstableCoreDoNotImport.transformResult(res.json, resolvedOpts.transformer.output);
-                    if (!transformed.ok) {
-                        observer.error(TRPCClientError.TRPCClientError.from(transformed.error, {
-                            meta
-                        }));
-                        return;
-                    }
-                    observer.next({
-                        context: res.meta,
-                        result: transformed.result
-                    });
-                    observer.complete();
-                }).catch((cause)=>{
-                    observer.error(TRPCClientError.TRPCClientError.from(cause, {
-                        meta
-                    }));
-                });
-                return ()=>{
-                // noop
-                };
-            });
-        };
-    };
-}
-
-exports.httpLink = httpLink;

package/dist/links/httpSubscriptionLink.d.ts

@@ -1,26 +0,0 @@
-import type { AnyClientTypes, EventSourceLike, inferClientTypes, InferrableClientTypes } from '@trpc/server/unstable-core-do-not-import';
-import { type TransformerOptions } from '../unstable-internals';
-import { type UrlOptionsWithConnectionParams } from './internals/urlWithConnectionParams';
-import type { Operation, TRPCLink } from './types';
-type HTTPSubscriptionLinkOptions<TRoot extends AnyClientTypes, TEventSource extends EventSourceLike.AnyConstructor = typeof EventSource> = {
-    /**
-     * EventSource ponyfill
-     */
-    EventSource?: TEventSource;
-    /**
-     * EventSource options or a callback that returns them
-     */
-    eventSourceOptions?: EventSourceLike.InitDictOf<TEventSource> | ((opts: {
-        op: Operation;
-    }) => EventSourceLike.InitDictOf<TEventSource> | Promise<EventSourceLike.InitDictOf<TEventSource>>);
-} & TransformerOptions<TRoot> & UrlOptionsWithConnectionParams;
-/**
- * @see https://trpc.io/docs/client/links/httpSubscriptionLink
- */
-export declare function httpSubscriptionLink<TInferrable extends InferrableClientTypes, TEventSource extends EventSourceLike.AnyConstructor>(opts: HTTPSubscriptionLinkOptions<inferClientTypes<TInferrable>, TEventSource>): TRPCLink<TInferrable>;
-/**
- * @deprecated use {@link httpSubscriptionLink} instead
- */
-export declare const unstable_httpSubscriptionLink: typeof httpSubscriptionLink;
-export {};
-//# sourceMappingURL=httpSubscriptionLink.d.ts.map

package/dist/links/httpSubscriptionLink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpSubscriptionLink.d.ts","sourceRoot":"","sources":["../../src/links/httpSubscriptionLink.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,0CAA0C,CAAC;AAUlD,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhF,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAiBnD,KAAK,2BAA2B,CAC9B,KAAK,SAAS,cAAc,EAC5B,YAAY,SAAS,eAAe,CAAC,cAAc,GAAG,OAAO,WAAW,IACtE;IACF;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B;;OAEG;IACH,kBAAkB,CAAC,EACf,eAAe,CAAC,UAAU,CAAC,YAAY,CAAC,GACxC,CAAC,CAAC,IAAI,EAAE;QACN,EAAE,EAAE,SAAS,CAAC;KACf,KACG,eAAe,CAAC,UAAU,CAAC,YAAY,CAAC,GACxC,OAAO,CAAC,eAAe,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAC5D,GAAG,kBAAkB,CAAC,KAAK,CAAC,GAC3B,8BAA8B,CAAC;AAEjC;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,qBAAqB,EACzC,YAAY,SAAS,eAAe,CAAC,cAAc,EAEnD,IAAI,EAAE,2BAA2B,CAC/B,gBAAgB,CAAC,WAAW,CAAC,EAC7B,YAAY,CACb,GACA,QAAQ,CAAC,WAAW,CAAC,CAuKvB;AAED;;GAEG;AACH,eAAO,MAAM,6BAA6B,6BAAuB,CAAC"}

package/dist/links/httpSubscriptionLink.js

@@ -1,177 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-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');
-var urlWithConnectionParams$1 = require('./internals/urlWithConnectionParams.js');
-
-async function urlWithConnectionParams(opts) {
-    let url = await urlWithConnectionParams$1.resultOf(opts.url);
-    if (opts.connectionParams) {
-        const params = await urlWithConnectionParams$1.resultOf(opts.connectionParams);
-        const prefix = url.includes('?') ? '&' : '?';
-        url += prefix + 'connectionParams=' + encodeURIComponent(JSON.stringify(params));
-    }
-    return url;
-}
-/**
- * @see https://trpc.io/docs/client/links/httpSubscriptionLink
- */ function httpSubscriptionLink(opts) {
-    const transformer$1 = transformer.getTransformer(opts.transformer);
-    return ()=>{
-        return ({ op })=>{
-            return observable.observable((observer)=>{
-                const { type, path, input } = op;
-                /* istanbul ignore if -- @preserve */ if (type !== 'subscription') {
-                    throw new Error('httpSubscriptionLink only supports subscriptions');
-                }
-                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: state
-                        });
-                    }
-                });
-                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 (unstableCoreDoNotImport.retryableRpcCodes.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`)
-                                    });
-                                }
-                        }
-                    }
-                    observer.next({
-                        result: {
-                            type: 'stopped'
-                        }
-                    });
-                    connectionState.next({
-                        type: 'state',
-                        state: 'idle',
-                        error: null
-                    });
-                    observer.complete();
-                }).catch((error)=>{
-                    observer.error(TRPCClientError.TRPCClientError.from(error));
-                });
-                return ()=>{
-                    observer.complete();
-                    ac.abort();
-                    connectionSub.unsubscribe();
-                };
-            });
-        };
-    };
-}
-/**
- * @deprecated use {@link httpSubscriptionLink} instead
- */ const unstable_httpSubscriptionLink = httpSubscriptionLink;
-
-exports.httpSubscriptionLink = httpSubscriptionLink;
-exports.unstable_httpSubscriptionLink = unstable_httpSubscriptionLink;