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

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

@@ -1,23 +0,0 @@
-import { type TRPCRequestInfo } from '@trpc/server/http';
-/**
- * Get the result of a value or function that returns a value
- * It also optionally accepts typesafe arguments for the function
- */
-export declare const resultOf: <T, TArgs extends any[]>(value: T | ((...args: TArgs) => T), ...args: TArgs) => T;
-/**
- * A value that can be wrapped in callback
- */
-export type CallbackOrValue<T> = T | (() => T | Promise<T>);
-export interface UrlOptionsWithConnectionParams {
-    /**
-     * The URL to connect to (can be a function that returns a URL)
-     */
-    url: CallbackOrValue<string>;
-    /**
-     * Connection params that are available in `createContext()`
-     * - For `wsLink`/`wsClient`, these are sent as the first message
-     * - For `httpSubscriptionLink`, these are serialized as part of the URL under the `connectionParams` query
-     */
-    connectionParams?: CallbackOrValue<TRPCRequestInfo['connectionParams']>;
-}
-//# sourceMappingURL=urlWithConnectionParams.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"urlWithConnectionParams.d.ts","sourceRoot":"","sources":["../../../src/links/internals/urlWithConnectionParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,KAAK,SAAS,GAAG,EAAE,EAC7C,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,CAAC,CAAC,EAClC,GAAG,MAAM,KAAK,KACb,CAIF,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAE5D,MAAM,WAAW,8BAA8B;IAC7C;;OAEG;IACH,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAE7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,eAAe,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAC;CACzE"}

package/dist/links/internals/urlWithConnectionParams.js

@@ -1,10 +0,0 @@
-'use strict';
-
-/**
- * Get the result of a value or function that returns a value
- * It also optionally accepts typesafe arguments for the function
- */ const resultOf = (value, ...args)=>{
-    return typeof value === 'function' ? value(...args) : value;
-};
-
-exports.resultOf = resultOf;

package/dist/links/internals/urlWithConnectionParams.mjs

@@ -1,8 +0,0 @@
-/**
- * Get the result of a value or function that returns a value
- * It also optionally accepts typesafe arguments for the function
- */ const resultOf = (value, ...args)=>{
-    return typeof value === 'function' ? value(...args) : value;
-};
-
-export { resultOf };

package/dist/links/localLink.d.ts

@@ -1,15 +0,0 @@
-import { type AnyRouter, type ErrorHandlerOptions, type inferClientTypes, type inferRouterContext } from '@trpc/server/unstable-core-do-not-import';
-import type { TransformerOptions } from '../internals/transformer';
-import type { TRPCLink } from './types';
-export type LocalLinkOptions<TRouter extends AnyRouter> = {
-    router: TRouter;
-    createContext: () => Promise<inferRouterContext<TRouter>>;
-    onError?: (opts: ErrorHandlerOptions<inferRouterContext<TRouter>>) => void;
-} & TransformerOptions<inferClientTypes<TRouter>>;
-/**
- * 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
- */
-export declare function experimental_localLink<TRouter extends AnyRouter>(opts: LocalLinkOptions<TRouter>): TRPCLink<TRouter>;
-//# sourceMappingURL=localLink.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"localLink.d.ts","sourceRoot":"","sources":["../../src/links/localLink.ts"],"names":[],"mappings":"AAOA,OAAO,EAQL,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,0CAA0C,CAAC;AAIlD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,SAAS,IAAI;IACxD,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,mBAAmB,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC;CAC5E,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,SAAS,SAAS,EAC9D,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAC9B,QAAQ,CAAC,OAAO,CAAC,CA2OnB"}

package/dist/links/localLink.js

@@ -1,333 +0,0 @@
-'use strict';
-
-var server = require('@trpc/server');
-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 transformer = require('../internals/transformer.js');
-var TRPCClientError = require('../TRPCClientError.js');
-
-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$1 = 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$1.input.serialize(chunk));
-        const deserialized = JSON.parse(transformer$1.output.deserialize(serialized));
-        return deserialized;
-    };
-    return ()=>({ op })=>observable.observable((observer)=>{
-                let ctx = undefined;
-                const ac = new AbortController();
-                const signal = signals.raceAbortSignals(op.signal, ac.signal);
-                const signalPromise = signals.abortSignalToPromise(signal);
-                signalPromise.catch(()=>{
-                // prevent unhandled rejection
-                });
-                let input = op.input;
-                async function runProcedure(newInput) {
-                    input = newInput;
-                    ctx = await opts.createContext();
-                    return unstableCoreDoNotImport.callProcedure({
-                        router: opts.router,
-                        path: op.path,
-                        getRawInput: async ()=>newInput,
-                        ctx,
-                        type: op.type,
-                        signal
-                    });
-                }
-                function onErrorCallback(cause) {
-                    if (unstableCoreDoNotImport.isAbortError(cause)) {
-                        return;
-                    }
-                    opts.onError?.({
-                        error: server.getTRPCErrorFromUnknown(cause),
-                        type: op.type,
-                        path: op.path,
-                        input,
-                        ctx
-                    });
-                }
-                function coerceToTRPCClientError(cause) {
-                    if (TRPCClientError.isTRPCClientError(cause)) {
-                        return cause;
-                    }
-                    const error = server.getTRPCErrorFromUnknown(cause);
-                    const shape = server.getTRPCErrorShape({
-                        config: opts.router._def._config,
-                        ctx,
-                        error,
-                        input,
-                        path: op.path,
-                        type: op.type
-                    });
-                    return TRPCClientError.TRPCClientError.from({
-                        error: transformChunk(shape)
-                    });
-                }
-                unstableCoreDoNotImport.run(async ()=>{
-                    switch(op.type){
-                        case 'query':
-                        case 'mutation':
-                            {
-                                const result = await runProcedure(op.input);
-                                if (!unstableCoreDoNotImport.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, unstableCoreDoNotImport.iteratorResource(result), true);
-                                                ;
-                                                const _finally = _ts_add_disposable_resource(env, unstableCoreDoNotImport.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 = observable.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, unstableCoreDoNotImport.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.inputWithTrackedEventId(op.input, lastEventId));
-                                            if (!unstableCoreDoNotImport.isAsyncIterable(result)) {
-                                                throw new Error('Expected an async iterable');
-                                            }
-                                            const iterator = _ts_add_disposable_resource(env, unstableCoreDoNotImport.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 (unstableCoreDoNotImport.isAbortError(cause)) {
-                                                        return;
-                                                    }
-                                                    const error = server.getTRPCErrorFromUnknown(cause);
-                                                    if (!unstableCoreDoNotImport.retryableRpcCodes.includes(rpc.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 (server.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();
-                };
-            });
-}
-
-exports.experimental_localLink = experimental_localLink;