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

package/dist/links/localLink.mjs

@@ -1,331 +0,0 @@
-import { getTRPCErrorFromUnknown, isTrackedEnvelope, getTRPCErrorShape } from '@trpc/server';
-import { observable, behaviorSubject } from '@trpc/server/observable';
-import { TRPC_ERROR_CODES_BY_KEY } from '@trpc/server/rpc';
-import { run, makeResource, isAsyncIterable, iteratorResource, isAbortError, retryableRpcCodes, callProcedure } from '@trpc/server/unstable-core-do-not-import';
-import { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId.mjs';
-import { raceAbortSignals, abortSignalToPromise } from '../internals/signals.mjs';
-import { getTransformer } from '../internals/transformer.mjs';
-import { isTRPCClientError, TRPCClientError } from '../TRPCClientError.mjs';
-
-function _ts_add_disposable_resource(env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() {
-            try {
-                inner.call(this);
-            } catch (e) {
-                return Promise.reject(e);
-            }
-        };
-        env.stack.push({
-            value: value,
-            dispose: dispose,
-            async: async
-        });
-    } else if (async) {
-        env.stack.push({
-            async: true
-        });
-    }
-    return value;
-}
-function _ts_dispose_resources(env) {
-    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
-        function fail(e) {
-            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while(r = env.stack.pop()){
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-                            fail(e);
-                            return next();
-                        });
-                    } else s |= 1;
-                } catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    })(env);
-}
-/**
- * localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.
- *
- * @see https://trpc.io/docs/links/localLink
- */ function experimental_localLink(opts) {
-    const transformer = getTransformer(opts.transformer);
-    const transformChunk = (chunk)=>{
-        if (opts.transformer) {
-            // assume transformer will do the right thing
-            return chunk;
-        }
-        // Special case for undefined, because `JSON.stringify(undefined)` throws
-        if (chunk === undefined) {
-            return chunk;
-        }
-        const serialized = JSON.stringify(transformer.input.serialize(chunk));
-        const deserialized = JSON.parse(transformer.output.deserialize(serialized));
-        return deserialized;
-    };
-    return ()=>({ op })=>observable((observer)=>{
-                let ctx = undefined;
-                const ac = new AbortController();
-                const signal = raceAbortSignals(op.signal, ac.signal);
-                const signalPromise = abortSignalToPromise(signal);
-                signalPromise.catch(()=>{
-                // prevent unhandled rejection
-                });
-                let input = op.input;
-                async function runProcedure(newInput) {
-                    input = newInput;
-                    ctx = await opts.createContext();
-                    return callProcedure({
-                        router: opts.router,
-                        path: op.path,
-                        getRawInput: async ()=>newInput,
-                        ctx,
-                        type: op.type,
-                        signal
-                    });
-                }
-                function onErrorCallback(cause) {
-                    if (isAbortError(cause)) {
-                        return;
-                    }
-                    opts.onError?.({
-                        error: getTRPCErrorFromUnknown(cause),
-                        type: op.type,
-                        path: op.path,
-                        input,
-                        ctx
-                    });
-                }
-                function coerceToTRPCClientError(cause) {
-                    if (isTRPCClientError(cause)) {
-                        return cause;
-                    }
-                    const error = getTRPCErrorFromUnknown(cause);
-                    const shape = getTRPCErrorShape({
-                        config: opts.router._def._config,
-                        ctx,
-                        error,
-                        input,
-                        path: op.path,
-                        type: op.type
-                    });
-                    return TRPCClientError.from({
-                        error: transformChunk(shape)
-                    });
-                }
-                run(async ()=>{
-                    switch(op.type){
-                        case 'query':
-                        case 'mutation':
-                            {
-                                const result = await runProcedure(op.input);
-                                if (!isAsyncIterable(result)) {
-                                    observer.next({
-                                        result: {
-                                            data: transformChunk(result)
-                                        }
-                                    });
-                                    observer.complete();
-                                    break;
-                                }
-                                observer.next({
-                                    result: {
-                                        data: async function*() {
-                                            const env = {
-                                                stack: [],
-                                                error: void 0,
-                                                hasError: false
-                                            };
-                                            try {
-                                                const iterator = _ts_add_disposable_resource(env, iteratorResource(result), true);
-                                                ;
-                                                const _finally = _ts_add_disposable_resource(env, makeResource({}, ()=>{
-                                                    observer.complete();
-                                                }), false);
-                                                ;
-                                                try {
-                                                    while(true){
-                                                        const res = await Promise.race([
-                                                            iterator.next(),
-                                                            signalPromise
-                                                        ]);
-                                                        if (res.done) {
-                                                            return transformChunk(res.value);
-                                                        }
-                                                        yield transformChunk(res.value);
-                                                    }
-                                                } catch (cause) {
-                                                    onErrorCallback(cause);
-                                                    throw coerceToTRPCClientError(cause);
-                                                }
-                                            } catch (e) {
-                                                env.error = e;
-                                                env.hasError = true;
-                                            } finally{
-                                                const result = _ts_dispose_resources(env);
-                                                if (result) await result;
-                                            }
-                                        }()
-                                    }
-                                });
-                                break;
-                            }
-                        case 'subscription':
-                            {
-                                const env = {
-                                    stack: [],
-                                    error: void 0,
-                                    hasError: false
-                                };
-                                try {
-                                    const connectionState = behaviorSubject({
-                                        type: 'state',
-                                        state: 'connecting',
-                                        error: null
-                                    });
-                                    const connectionSub = connectionState.subscribe({
-                                        next (state) {
-                                            observer.next({
-                                                result: state
-                                            });
-                                        }
-                                    });
-                                    let lastEventId = undefined;
-                                    const _finally = _ts_add_disposable_resource(env, makeResource({}, async ()=>{
-                                        observer.complete();
-                                        connectionState.next({
-                                            type: 'state',
-                                            state: 'idle',
-                                            error: null
-                                        });
-                                        connectionSub.unsubscribe();
-                                    }), false);
-                                    ;
-                                    while(true){
-                                        const env = {
-                                            stack: [],
-                                            error: void 0,
-                                            hasError: false
-                                        };
-                                        try {
-                                            const result = await runProcedure(inputWithTrackedEventId(op.input, lastEventId));
-                                            if (!isAsyncIterable(result)) {
-                                                throw new Error('Expected an async iterable');
-                                            }
-                                            const iterator = _ts_add_disposable_resource(env, iteratorResource(result), true);
-                                            ;
-                                            observer.next({
-                                                result: {
-                                                    type: 'started'
-                                                }
-                                            });
-                                            connectionState.next({
-                                                type: 'state',
-                                                state: 'pending',
-                                                error: null
-                                            });
-                                            // Use a while loop to handle errors and reconnects
-                                            while(true){
-                                                let res;
-                                                try {
-                                                    res = await Promise.race([
-                                                        iterator.next(),
-                                                        signalPromise
-                                                    ]);
-                                                } catch (cause) {
-                                                    if (isAbortError(cause)) {
-                                                        return;
-                                                    }
-                                                    const error = getTRPCErrorFromUnknown(cause);
-                                                    if (!retryableRpcCodes.includes(TRPC_ERROR_CODES_BY_KEY[error.code])) {
-                                                        throw coerceToTRPCClientError(error);
-                                                    }
-                                                    onErrorCallback(error);
-                                                    connectionState.next({
-                                                        type: 'state',
-                                                        state: 'connecting',
-                                                        error: coerceToTRPCClientError(error)
-                                                    });
-                                                    break;
-                                                }
-                                                if (res.done) {
-                                                    return;
-                                                }
-                                                let chunk;
-                                                if (isTrackedEnvelope(res.value)) {
-                                                    lastEventId = res.value[0];
-                                                    chunk = {
-                                                        id: res.value[0],
-                                                        data: {
-                                                            id: res.value[0],
-                                                            data: res.value[1]
-                                                        }
-                                                    };
-                                                } else {
-                                                    chunk = {
-                                                        data: res.value
-                                                    };
-                                                }
-                                                observer.next({
-                                                    result: {
-                                                        ...chunk,
-                                                        data: transformChunk(chunk.data)
-                                                    }
-                                                });
-                                            }
-                                        } catch (e) {
-                                            env.error = e;
-                                            env.hasError = true;
-                                        } finally{
-                                            const result = _ts_dispose_resources(env);
-                                            if (result) await result;
-                                        }
-                                    }
-                                    break;
-                                } catch (e) {
-                                    env.error = e;
-                                    env.hasError = true;
-                                } finally{
-                                    _ts_dispose_resources(env);
-                                }
-                            }
-                    }
-                }).catch((cause)=>{
-                    onErrorCallback(cause);
-                    observer.error(coerceToTRPCClientError(cause));
-                });
-                return ()=>{
-                    ac.abort();
-                };
-            });
-}
-
-export { experimental_localLink };

package/dist/links/loggerLink.d.ts

@@ -1,52 +0,0 @@
-import type { AnyRouter, InferrableClientTypes } from '@trpc/server/unstable-core-do-not-import';
-import type { TRPCClientError } from '../TRPCClientError';
-import type { Operation, OperationResultEnvelope, TRPCLink } from './types';
-type ConsoleEsque = {
-    log: (...args: any[]) => void;
-    error: (...args: any[]) => void;
-};
-type EnableFnOptions<TRouter extends InferrableClientTypes> = {
-    direction: 'down';
-    result: OperationResultEnvelope<unknown, TRPCClientError<TRouter>> | TRPCClientError<TRouter>;
-} | (Operation & {
-    direction: 'up';
-});
-type EnabledFn<TRouter extends AnyRouter> = (opts: EnableFnOptions<TRouter>) => boolean;
-type LoggerLinkFnOptions<TRouter extends AnyRouter> = Operation & ({
-    /**
-     * Request result
-     */
-    direction: 'down';
-    result: OperationResultEnvelope<unknown, TRPCClientError<TRouter>> | TRPCClientError<TRouter>;
-    elapsedMs: number;
-} | {
-    /**
-     * Request was just initialized
-     */
-    direction: 'up';
-});
-type LoggerLinkFn<TRouter extends AnyRouter> = (opts: LoggerLinkFnOptions<TRouter>) => void;
-type ColorMode = 'ansi' | 'css' | 'none';
-export interface LoggerLinkOptions<TRouter extends AnyRouter> {
-    logger?: LoggerLinkFn<TRouter>;
-    enabled?: EnabledFn<TRouter>;
-    /**
-     * Used in the built-in defaultLogger
-     */
-    console?: ConsoleEsque;
-    /**
-     * Color mode
-     * @default typeof window === 'undefined' ? 'ansi' : 'css'
-     */
-    colorMode?: ColorMode;
-    /**
-     * Include context in the log - defaults to false unless `colorMode` is 'css'
-     */
-    withContext?: boolean;
-}
-/**
- * @see https://trpc.io/docs/v11/client/links/loggerLink
- */
-export declare function loggerLink<TRouter extends AnyRouter = AnyRouter>(opts?: LoggerLinkOptions<TRouter>): TRPCLink<TRouter>;
-export {};
-//# sourceMappingURL=loggerLink.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"loggerLink.d.ts","sourceRoot":"","sources":["../../src/links/loggerLink.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACtB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE5E,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IAC9B,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACjC,CAAC;AAEF,KAAK,eAAe,CAAC,OAAO,SAAS,qBAAqB,IACtD;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EACF,uBAAuB,CAAC,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC,GAC1D,eAAe,CAAC,OAAO,CAAC,CAAC;CAC9B,GACD,CAAC,SAAS,GAAG;IACX,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC,CAAC;AACP,KAAK,SAAS,CAAC,OAAO,SAAS,SAAS,IAAI,CAC1C,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,KAC3B,OAAO,CAAC;AAEb,KAAK,mBAAmB,CAAC,OAAO,SAAS,SAAS,IAAI,SAAS,GAC7D,CACI;IACE;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EACF,uBAAuB,CAAC,OAAO,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC,GAC1D,eAAe,CAAC,OAAO,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB,GACD;IACE;;OAEG;IACH,SAAS,EAAE,IAAI,CAAC;CACjB,CACJ,CAAC;AAEJ,KAAK,YAAY,CAAC,OAAO,SAAS,SAAS,IAAI,CAC7C,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC,KAC/B,IAAI,CAAC;AAEV,KAAK,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAEzC,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,SAAS;IAC1D,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC7B;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;OAEG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAqID;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,SAAS,GAAG,SAAS,EAC9D,IAAI,GAAE,iBAAiB,CAAC,OAAO,CAAM,GACpC,QAAQ,CAAC,OAAO,CAAC,CAoDnB"}

package/dist/links/loggerLink.js

@@ -1,178 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-
-/// <reference lib="dom.iterable" />
-// `dom.iterable` types are explicitly required for extracting `FormData` values,
-// as all implementations of `Symbol.iterable` are separated from the main `dom` types.
-// Using triple-slash directive makes sure that it will be available,
-// even if end-user `tsconfig.json` omits it in the `lib` array.
-function isFormData(value) {
-    if (typeof FormData === 'undefined') {
-        // FormData is not supported
-        return false;
-    }
-    return value instanceof FormData;
-}
-const palettes = {
-    css: {
-        query: [
-            '72e3ff',
-            '3fb0d8'
-        ],
-        mutation: [
-            'c5a3fc',
-            '904dfc'
-        ],
-        subscription: [
-            'ff49e1',
-            'd83fbe'
-        ]
-    },
-    ansi: {
-        regular: {
-            // Cyan background, black and white text respectively
-            query: [
-                '\x1b[30;46m',
-                '\x1b[97;46m'
-            ],
-            // Magenta background, black and white text respectively
-            mutation: [
-                '\x1b[30;45m',
-                '\x1b[97;45m'
-            ],
-            // Green background, black and white text respectively
-            subscription: [
-                '\x1b[30;42m',
-                '\x1b[97;42m'
-            ]
-        },
-        bold: {
-            query: [
-                '\x1b[1;30;46m',
-                '\x1b[1;97;46m'
-            ],
-            mutation: [
-                '\x1b[1;30;45m',
-                '\x1b[1;97;45m'
-            ],
-            subscription: [
-                '\x1b[1;30;42m',
-                '\x1b[1;97;42m'
-            ]
-        }
-    }
-};
-function constructPartsAndArgs(opts) {
-    const { direction, type, withContext, path, id, input } = opts;
-    const parts = [];
-    const args = [];
-    if (opts.colorMode === 'none') {
-        parts.push(direction === 'up' ? '>>' : '<<', type, `#${id}`, path);
-    } else if (opts.colorMode === 'ansi') {
-        const [lightRegular, darkRegular] = palettes.ansi.regular[type];
-        const [lightBold, darkBold] = palettes.ansi.bold[type];
-        const reset = '\x1b[0m';
-        parts.push(direction === 'up' ? lightRegular : darkRegular, direction === 'up' ? '>>' : '<<', type, direction === 'up' ? lightBold : darkBold, `#${id}`, path, reset);
-    } else {
-        // css color mode
-        const [light, dark] = palettes.css[type];
-        const css = `
-    background-color: #${direction === 'up' ? light : dark};
-    color: ${direction === 'up' ? 'black' : 'white'};
-    padding: 2px;
-  `;
-        parts.push('%c', direction === 'up' ? '>>' : '<<', type, `#${id}`, `%c${path}%c`, '%O');
-        args.push(css, `${css}; font-weight: bold;`, `${css}; font-weight: normal;`);
-    }
-    if (direction === 'up') {
-        args.push(withContext ? {
-            input,
-            context: opts.context
-        } : {
-            input
-        });
-    } else {
-        args.push({
-            input,
-            result: opts.result,
-            elapsedMs: opts.elapsedMs,
-            ...withContext && {
-                context: opts.context
-            }
-        });
-    }
-    return {
-        parts,
-        args
-    };
-}
-// maybe this should be moved to it's own package
-const defaultLogger = ({ c = console, colorMode = 'css', withContext })=>(props)=>{
-        const rawInput = props.input;
-        const input = isFormData(rawInput) ? Object.fromEntries(rawInput) : rawInput;
-        const { parts, args } = constructPartsAndArgs({
-            ...props,
-            colorMode,
-            input,
-            withContext
-        });
-        const fn = props.direction === 'down' && props.result && (props.result instanceof Error || 'error' in props.result.result && props.result.result.error) ? 'error' : 'log';
-        c[fn].apply(null, [
-            parts.join(' ')
-        ].concat(args));
-    };
-/**
- * @see https://trpc.io/docs/v11/client/links/loggerLink
- */ function loggerLink(opts = {}) {
-    const { enabled = ()=>true } = opts;
-    const colorMode = opts.colorMode ?? (typeof window === 'undefined' ? 'ansi' : 'css');
-    const withContext = opts.withContext ?? colorMode === 'css';
-    const { logger = defaultLogger({
-        c: opts.console,
-        colorMode,
-        withContext
-    }) } = opts;
-    return ()=>{
-        return ({ op, next })=>{
-            return observable.observable((observer)=>{
-                // ->
-                if (enabled({
-                    ...op,
-                    direction: 'up'
-                })) {
-                    logger({
-                        ...op,
-                        direction: 'up'
-                    });
-                }
-                const requestStartTime = Date.now();
-                function logResult(result) {
-                    const elapsedMs = Date.now() - requestStartTime;
-                    if (enabled({
-                        ...op,
-                        direction: 'down',
-                        result
-                    })) {
-                        logger({
-                            ...op,
-                            direction: 'down',
-                            elapsedMs,
-                            result
-                        });
-                    }
-                }
-                return next(op).pipe(observable.tap({
-                    next (result) {
-                        logResult(result);
-                    },
-                    error (result) {
-                        logResult(result);
-                    }
-                })).subscribe(observer);
-            });
-        };
-    };
-}
-
-exports.loggerLink = loggerLink;

package/dist/links/retryLink.d.ts

@@ -1,33 +0,0 @@
-import type { InferrableClientTypes } from '@trpc/server/unstable-core-do-not-import';
-import type { TRPCClientError } from '../TRPCClientError';
-import type { Operation, TRPCLink } from './types';
-interface RetryLinkOptions<TInferrable extends InferrableClientTypes> {
-    /**
-     * The retry function
-     */
-    retry: (opts: RetryFnOptions<TInferrable>) => boolean;
-    /**
-     * The delay between retries in ms (defaults to 0)
-     */
-    retryDelayMs?: (attempt: number) => number;
-}
-interface RetryFnOptions<TInferrable extends InferrableClientTypes> {
-    /**
-     * The operation that failed
-     */
-    op: Operation;
-    /**
-     * The error that occurred
-     */
-    error: TRPCClientError<TInferrable>;
-    /**
-     * The number of attempts that have been made (including the first call)
-     */
-    attempts: number;
-}
-/**
- * @see https://trpc.io/docs/v11/client/links/retryLink
- */
-export declare function retryLink<TInferrable extends InferrableClientTypes>(opts: RetryLinkOptions<TInferrable>): TRPCLink<TInferrable>;
-export {};
-//# sourceMappingURL=retryLink.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"retryLink.d.ts","sourceRoot":"","sources":["../../src/links/retryLink.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEtF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnD,UAAU,gBAAgB,CAAC,WAAW,SAAS,qBAAqB;IAClE;;OAEG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC;IACtD;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5C;AAED,UAAU,cAAc,CAAC,WAAW,SAAS,qBAAqB;IAChE;;OAEG;IACH,EAAE,EAAE,SAAS,CAAC;IACd;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC;IACpC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,WAAW,SAAS,qBAAqB,EACjE,IAAI,EAAE,gBAAgB,CAAC,WAAW,CAAC,GAClC,QAAQ,CAAC,WAAW,CAAC,CA4EvB"}

package/dist/links/retryLink.js

@@ -1,72 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var inputWithTrackedEventId = require('../internals/inputWithTrackedEventId.js');
-
-/* istanbul ignore file -- @preserve */ // We're not actually exporting this link
-/**
- * @see https://trpc.io/docs/v11/client/links/retryLink
- */ function retryLink(opts) {
-    // initialized config
-    return ()=>{
-        // initialized in app
-        return (callOpts)=>{
-            // initialized for request
-            return observable.observable((observer)=>{
-                let next$;
-                let callNextTimeout = undefined;
-                let lastEventId = undefined;
-                attempt(1);
-                function opWithLastEventId() {
-                    const op = callOpts.op;
-                    if (!lastEventId) {
-                        return op;
-                    }
-                    return {
-                        ...op,
-                        input: inputWithTrackedEventId.inputWithTrackedEventId(op.input, lastEventId)
-                    };
-                }
-                function attempt(attempts) {
-                    const op = opWithLastEventId();
-                    next$ = callOpts.next(op).subscribe({
-                        error (error) {
-                            const shouldRetry = opts.retry({
-                                op,
-                                attempts,
-                                error
-                            });
-                            if (!shouldRetry) {
-                                observer.error(error);
-                                return;
-                            }
-                            const delayMs = opts.retryDelayMs?.(attempts) ?? 0;
-                            if (delayMs <= 0) {
-                                attempt(attempts + 1);
-                                return;
-                            }
-                            callNextTimeout = setTimeout(()=>attempt(attempts + 1), delayMs);
-                        },
-                        next (envelope) {
-                            //
-                            if ((!envelope.result.type || envelope.result.type === 'data') && envelope.result.id) {
-                                //
-                                lastEventId = envelope.result.id;
-                            }
-                            observer.next(envelope);
-                        },
-                        complete () {
-                            observer.complete();
-                        }
-                    });
-                }
-                return ()=>{
-                    next$.unsubscribe();
-                    clearTimeout(callNextTimeout);
-                };
-            });
-        };
-    };
-}
-
-exports.retryLink = retryLink;