@trpc/client 9.24.0 → 9.25.0

package/dist/index.ts.js

@@ -0,0 +1,576 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+var TRPCClientError = /** @class */ (function (_super) {
+    __extends(TRPCClientError, _super);
+    function TRPCClientError(message, opts) {
+        var _a, _b, _c, _d;
+        var _this = this;
+        var cause = (_a = opts.cause) !== null && _a !== void 0 ? _a : opts.originalError;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore https://github.com/tc39/proposal-error-cause
+        _this = _super.call(this, message, { cause: cause }) || this;
+        _this.isDone = (_b = opts.isDone) !== null && _b !== void 0 ? _b : false;
+        _this.cause = _this.originalError = cause;
+        _this.shape = (_c = opts.result) === null || _c === void 0 ? void 0 : _c.error;
+        _this.data = (_d = opts.result) === null || _d === void 0 ? void 0 : _d.error.data;
+        _this.name = 'TRPCClientError';
+        Object.setPrototypeOf(_this, TRPCClientError.prototype);
+        return _this;
+    }
+    TRPCClientError.from = function (result, opts) {
+        var _a;
+        if (opts === void 0) { opts = {}; }
+        if (!(result instanceof Error)) {
+            return new TRPCClientError((_a = result.error.message) !== null && _a !== void 0 ? _a : '', __assign(__assign({}, opts), { cause: null, result: result }));
+        }
+        if (result.name === 'TRPCClientError') {
+            return result;
+        }
+        return new TRPCClientError(result.message, __assign(__assign({}, opts), { cause: result, result: null }));
+    };
+    return TRPCClientError;
+}(Error));
+
+function getWindow() {
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    return global;
+}
+function getAbortController(ac) {
+    var win = getWindow();
+    return ac || win.AbortController || null;
+}
+
+function getFetch(f) {
+    if (f) {
+        return f;
+    }
+    var win = getWindow();
+    if (win.fetch) {
+        return typeof win.fetch.bind === 'function'
+            ? win.fetch.bind(win)
+            : win.fetch;
+    }
+    throw new Error('No fetch implementation found');
+}
+
+var TRPCAbortError = /** @class */ (function (_super) {
+    __extends(TRPCAbortError, _super);
+    function TRPCAbortError() {
+        var _this = _super.call(this, 'The operation was aborted.') || this;
+        _this.name = 'TRPCAbortError';
+        Object.setPrototypeOf(_this, TRPCAbortError.prototype);
+        return _this;
+    }
+    return TRPCAbortError;
+}(Error));
+
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * Less configuration, no caching, and allows you to cancel requests
+ * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
+ */
+function dataLoader(fetchMany, opts) {
+    var batch = null;
+    var dispatchTimer = null;
+    var destroyTimerAndBatch = function () {
+        clearTimeout(dispatchTimer);
+        dispatchTimer = null;
+        batch = null;
+    };
+    function dispatch() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        var batchCopy = batch;
+        destroyTimerAndBatch();
+        var _a = fetchMany(batchCopy.items.map(function (v) { return v.key; })), promise = _a.promise, cancel = _a.cancel;
+        batchCopy.cancel = cancel;
+        promise
+            .then(function (result) {
+            for (var i = 0; i < result.length; i++) {
+                var value = result[i];
+                batchCopy.items[i].resolve(value);
+            }
+        })["catch"](function (cause) {
+            for (var _i = 0, _a = batchCopy.items; _i < _a.length; _i++) {
+                var item = _a[_i];
+                item.reject(cause);
+            }
+        });
+    }
+    function load(key) {
+        var batchItem = {
+            cancelled: false,
+            key: key,
+        };
+        if (!batch) {
+            batch = {
+                items: [],
+                cancel: function () {
+                    destroyTimerAndBatch();
+                },
+            };
+        }
+        var thisBatch = batch;
+        var promise = new Promise(function (resolve, reject) {
+            var item = batchItem;
+            item.reject = reject;
+            item.resolve = resolve;
+            thisBatch.items.push(item);
+            if (typeof (opts === null || opts === void 0 ? void 0 : opts.maxBatchSize) !== 'undefined' &&
+                thisBatch.items.length >= opts.maxBatchSize) {
+                dispatch();
+                return;
+            }
+        });
+        if (!dispatchTimer) {
+            dispatchTimer = setTimeout(dispatch);
+        }
+        var cancel = function () {
+            batchItem.cancelled = true;
+            if (thisBatch.items.some(function (item) { return !item.cancelled; })) {
+                // there are still things that can be resolved
+                return;
+            }
+            thisBatch.cancel();
+        };
+        return { promise: promise, cancel: cancel };
+    }
+    return {
+        load: load,
+    };
+}
+
+// https://github.com/trpc/trpc/pull/669
+function arrayToDict(array) {
+    var dict = {};
+    for (var index = 0; index < array.length; index++) {
+        var element = array[index];
+        dict[index] = element;
+    }
+    return dict;
+}
+function httpRequest(props) {
+    var type = props.type, rt = props.runtime, path = props.path;
+    var ac = rt.AbortController ? new rt.AbortController() : null;
+    var method = {
+        query: 'GET',
+        mutation: 'POST',
+        subscription: 'PATCH',
+    };
+    var input = 'input' in props
+        ? rt.transformer.serialize(props.input)
+        : arrayToDict(props.inputs.map(function (_input) { return rt.transformer.serialize(_input); }));
+    function getUrl() {
+        var url = props.url + '/' + path;
+        var queryParts = [];
+        if ('inputs' in props) {
+            queryParts.push('batch=1');
+        }
+        if (type === 'query' && input !== undefined) {
+            queryParts.push("input=" + encodeURIComponent(JSON.stringify(input)));
+        }
+        if (queryParts.length) {
+            url += '?' + queryParts.join('&');
+        }
+        return url;
+    }
+    function getBody() {
+        if (type === 'query') {
+            return undefined;
+        }
+        return input !== undefined ? JSON.stringify(input) : undefined;
+    }
+    var promise = new Promise(function (resolve, reject) {
+        var url = getUrl();
+        Promise.resolve(rt.headers())
+            .then(function (rawHeaders) {
+            var headers = { 'content-type': 'application/json' };
+            for (var key in rawHeaders) {
+                var header = rawHeaders[key];
+                if (header !== undefined) {
+                    if (Array.isArray(header)) {
+                        headers[key] = header.join(',');
+                    }
+                    else {
+                        headers[key] = header;
+                    }
+                }
+            }
+            return rt.fetch(url, {
+                method: method[type],
+                signal: ac === null || ac === void 0 ? void 0 : ac.signal,
+                body: getBody(),
+                headers: headers,
+            });
+        })
+            .then(function (res) {
+            return res.json();
+        })
+            .then(function (json) {
+            resolve(json);
+        })["catch"](reject);
+    });
+    var cancel = function () {
+        ac === null || ac === void 0 ? void 0 : ac.abort();
+    };
+    return { promise: promise, cancel: cancel };
+}
+
+function transformRPCResponse(_a) {
+    var envelope = _a.envelope, runtime = _a.runtime;
+    if ('error' in envelope) {
+        return TRPCClientError.from(__assign(__assign({}, envelope), { error: runtime.transformer.deserialize(envelope.error) }));
+    }
+    if (envelope.result.type === 'data') {
+        return __assign(__assign({}, envelope.result), { data: runtime.transformer.deserialize(envelope.result.data) });
+    }
+    return envelope.result;
+}
+
+function httpBatchLink(opts) {
+    var url = opts.url, maxBatchSize = opts.maxBatchSize;
+    // initialized config
+    return function (runtime) {
+        var fetcher = function (type) { return function (keyInputPairs) {
+            var path = keyInputPairs.map(function (op) { return op.path; }).join(',');
+            var inputs = keyInputPairs.map(function (op) { return op.input; });
+            var _a = httpRequest({
+                url: url,
+                inputs: inputs,
+                path: path,
+                runtime: runtime,
+                type: type,
+            }), promise = _a.promise, cancel = _a.cancel;
+            return {
+                promise: promise.then(function (res) {
+                    if (!Array.isArray(res)) {
+                        return keyInputPairs.map(function () { return res; });
+                    }
+                    return res;
+                }),
+                cancel: cancel,
+            };
+        }; };
+        var query = dataLoader(fetcher('query'), {
+            maxBatchSize: maxBatchSize,
+        });
+        var mutation = dataLoader(fetcher('mutation'), {
+            maxBatchSize: maxBatchSize,
+        });
+        var subscription = dataLoader(fetcher('subscription'), { maxBatchSize: maxBatchSize });
+        var loaders = { query: query, subscription: subscription, mutation: mutation };
+        return function (_a) {
+            var op = _a.op, prev = _a.prev, onDestroy = _a.onDestroy;
+            var loader = loaders[op.type];
+            var _b = loader.load(op), promise = _b.promise, cancel = _b.cancel;
+            var isDone = false;
+            var prevOnce = function (result) {
+                if (isDone) {
+                    return;
+                }
+                isDone = true;
+                prev(result);
+            };
+            onDestroy(function () {
+                prevOnce(TRPCClientError.from(new TRPCAbortError(), { isDone: true }));
+                cancel();
+            });
+            promise
+                .then(function (envelope) {
+                prevOnce(transformRPCResponse({ envelope: envelope, runtime: runtime }));
+            })["catch"](function (cause) {
+                prevOnce(TRPCClientError.from(cause));
+            });
+        };
+    };
+}
+
+function observable() {
+    var listeners = [];
+    var value = null;
+    return {
+        subscribe: function (callbacks) {
+            var listener = {
+                callbacks: callbacks,
+                unsubscribe: function () {
+                    var _a, _b;
+                    var index = listeners.indexOf(listener);
+                    if (index !== -1) {
+                        listeners.splice(index, 1);
+                        (_b = (_a = listener.callbacks).onDone) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    }
+                },
+            };
+            listeners.push(listener);
+            return function () {
+                listener.unsubscribe();
+            };
+        },
+        next: function (newValue) {
+            var _a, _b;
+            var oldValue = value;
+            value = newValue;
+            if (oldValue !== newValue) {
+                for (var _i = 0, listeners_1 = listeners; _i < listeners_1.length; _i++) {
+                    var listener = listeners_1[_i];
+                    (_b = (_a = listener.callbacks).onNext) === null || _b === void 0 ? void 0 : _b.call(_a, newValue);
+                }
+            }
+        },
+        done: function () {
+            var _a, _b;
+            while (listeners.length) {
+                var listener = listeners.pop();
+                (_b = listener === null || listener === void 0 ? void 0 : (_a = listener.callbacks).onDone) === null || _b === void 0 ? void 0 : _b.call(_a);
+                listener === null || listener === void 0 ? void 0 : listener.unsubscribe();
+            }
+        },
+        error: function (error) {
+            var _a, _b;
+            for (var _i = 0, listeners_2 = listeners; _i < listeners_2.length; _i++) {
+                var listener = listeners_2[_i];
+                (_b = (_a = listener.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+            }
+        },
+    };
+}
+function observableSubject(initialValue) {
+    var $obs = observable();
+    var value = initialValue;
+    $obs.next(initialValue);
+    return __assign(__assign({}, $obs), { next: function (v) {
+            value = v;
+            $obs.next(v);
+        }, get: function () {
+            return value;
+        } });
+}
+
+function executeChain(opts) {
+    var $result = observableSubject(null);
+    var updateResult = function (result) {
+        if (result instanceof Error) {
+            $result.error(result);
+            if (result.isDone) {
+                $result.done();
+            }
+        }
+        else {
+            $result.next(result);
+        }
+    };
+    function walk(_a) {
+        var index = _a.index, op = _a.op, stack = _a.stack;
+        var link = opts.links[index];
+        var prev = index === 0 ? function (value) { return updateResult(value); } : stack[index - 1];
+        link({
+            op: op,
+            prev: prev,
+            next: function (op, prevOp) {
+                var prevStack = stack.slice();
+                prevStack[index] = prevOp;
+                walk({ index: index + 1, op: op, stack: prevStack });
+            },
+            onDestroy: function (callback) {
+                $result.subscribe({
+                    onDone: function () {
+                        callback();
+                    },
+                });
+            },
+        });
+    }
+    walk({ index: 0, op: opts.op, stack: [] });
+    return $result;
+}
+
+var idCounter = 0;
+function getRequestId() {
+    return ++idCounter;
+}
+var TRPCClient = /** @class */ (function () {
+    function TRPCClient(opts) {
+        var _this = this;
+        var transformer = opts.transformer
+            ? 'input' in opts.transformer
+                ? {
+                    serialize: opts.transformer.input.serialize,
+                    deserialize: opts.transformer.output.deserialize,
+                }
+                : opts.transformer
+            : {
+                serialize: function (data) { return data; },
+                deserialize: function (data) { return data; },
+            };
+        var _fetch = getFetch(opts === null || opts === void 0 ? void 0 : opts.fetch);
+        var AC = getAbortController(opts === null || opts === void 0 ? void 0 : opts.AbortController);
+        function getHeadersFn() {
+            if (opts.headers) {
+                var headers_1 = opts.headers;
+                return typeof headers_1 === 'function' ? headers_1 : function () { return headers_1; };
+            }
+            return function () { return ({}); };
+        }
+        this.runtime = {
+            transformer: transformer,
+            AbortController: AC,
+            fetch: _fetch,
+            headers: getHeadersFn(),
+        };
+        if ('links' in opts) {
+            this.links = opts.links.map(function (link) { return link(_this.runtime); });
+        }
+        else {
+            this.links = [
+                httpBatchLink({
+                    url: opts.url,
+                })(this.runtime),
+            ];
+        }
+    }
+    TRPCClient.prototype.$request = function (_a) {
+        var type = _a.type, input = _a.input, path = _a.path, _b = _a.context, context = _b === void 0 ? {} : _b;
+        var $result = executeChain({
+            links: this.links,
+            op: {
+                id: getRequestId(),
+                type: type,
+                path: path,
+                input: input,
+                context: context,
+            },
+        });
+        return $result;
+    };
+    TRPCClient.prototype.requestAsPromise = function (opts) {
+        var $result = this.$request(opts);
+        var promise = new Promise(function (resolve, reject) {
+            var res = $result.get();
+            if ((res === null || res === void 0 ? void 0 : res.type) === 'data') {
+                resolve(res.data);
+                $result.done();
+                return;
+            }
+            $result.subscribe({
+                onNext: function (result) {
+                    if ((result === null || result === void 0 ? void 0 : result.type) !== 'data') {
+                        return;
+                    }
+                    resolve(result.data);
+                    $result.done();
+                },
+                onError: function (err) {
+                    reject(err);
+                    $result.done();
+                },
+                onDone: function () {
+                    reject(TRPCClientError.from(new TRPCAbortError()));
+                },
+            });
+        });
+        promise.cancel = function () {
+            $result.done();
+        };
+        return promise;
+    };
+    TRPCClient.prototype.query = function (path) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var context = (_a = args[1]) === null || _a === void 0 ? void 0 : _a.context;
+        return this.requestAsPromise({
+            type: 'query',
+            path: path,
+            input: args[0],
+            context: context,
+        });
+    };
+    TRPCClient.prototype.mutation = function (path) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var context = (_a = args[1]) === null || _a === void 0 ? void 0 : _a.context;
+        return this.requestAsPromise({
+            type: 'mutation',
+            path: path,
+            input: args[0],
+            context: context,
+        });
+    };
+    TRPCClient.prototype.subscription = function (path, input, opts) {
+        var $res = this.$request({
+            type: 'subscription',
+            path: path,
+            input: input,
+            context: opts.context,
+        });
+        $res.subscribe({
+            onNext: function (output) {
+                var _a;
+                if (output) {
+                    (_a = opts.onNext) === null || _a === void 0 ? void 0 : _a.call(opts, output);
+                }
+            },
+            onError: function (err) {
+                var _a;
+                (_a = opts.onError) === null || _a === void 0 ? void 0 : _a.call(opts, err);
+            },
+            onDone: opts.onDone,
+        });
+        return function () {
+            $res.done();
+        };
+    };
+    return TRPCClient;
+}());
+
+function createTRPCClient(opts) {
+    return new TRPCClient(opts);
+}
+
+export { TRPCClientError, createTRPCClient, getFetch };

package/dist/internals/retryDelay.d.ts

@@ -0,0 +1,2 @@
+export declare const retryDelay: (attemptIndex: number) => number;
+//# sourceMappingURL=retryDelay.d.ts.map

package/dist/internals/retryDelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryDelay.d.ts","sourceRoot":"","sources":["../../src/internals/retryDelay.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,iBAAkB,MAAM,WACqB,CAAC"}

package/dist/packages/client/src/TRPCClientError.d.ts

@@ -0,0 +1,34 @@
+import { AnyRouter, Maybe, inferRouterError } from '@trpc/server';
+import { TRPCErrorResponse } from '@trpc/server/rpc';
+export interface TRPCClientErrorLike<TRouter extends AnyRouter> {
+    readonly message: string;
+    readonly shape: Maybe<inferRouterError<TRouter>>;
+    readonly data: Maybe<inferRouterError<TRouter>['data']>;
+}
+export declare class TRPCClientError<TRouter extends AnyRouter> extends Error implements TRPCClientErrorLike<TRouter> {
+    /**
+     * @deprecated use `cause`
+     */
+    readonly originalError: Maybe<Error>;
+    readonly cause: Maybe<Error>;
+    readonly shape: Maybe<inferRouterError<TRouter>>;
+    readonly data: Maybe<inferRouterError<TRouter>['data']>;
+    /**
+     * Fatal error - expect no more results after this error
+     * Used for when WebSockets disconnect prematurely.
+     */
+    readonly isDone: boolean;
+    constructor(message: string, opts: {
+        result: Maybe<TRPCErrorResponse<inferRouterError<TRouter>>>;
+        /**
+         * @deprecated use cause
+         **/
+        originalError?: Maybe<Error>;
+        cause?: Maybe<Error>;
+        isDone?: boolean;
+    });
+    static from<TRouter extends AnyRouter>(result: Error | TRPCErrorResponse<any>, opts?: {
+        isDone?: boolean;
+    }): TRPCClientError<TRouter>;
+}
+//# sourceMappingURL=TRPCClientError.d.ts.map

package/dist/packages/client/src/TRPCClientError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRPCClientError.d.ts","sourceRoot":"","sources":["../../../../src/TRPCClientError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,WAAW,mBAAmB,CAAC,OAAO,SAAS,SAAS;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;CACzD;AAED,qBAAa,eAAe,CAAC,OAAO,SAAS,SAAS,CACpD,SAAQ,KACR,YAAW,mBAAmB,CAAC,OAAO,CAAC;IAEvC;;OAEG;IACH,SAAgB,aAAa,eAAC;IAC9B,SAAgB,KAAK,eAAC;IACtB,SAAgB,KAAK,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,SAAgB,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D;;;OAGG;IACH,SAAgB,MAAM,EAAE,OAAO,CAAC;gBAG9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QACJ,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC5D;;YAEI;QACJ,aAAa,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAC7B,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QACrB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;WAkBW,IAAI,CAAC,OAAO,SAAS,SAAS,EAC1C,MAAM,EAAE,KAAK,GAAG,iBAAiB,CAAC,GAAG,CAAC,EACtC,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAC9B,eAAe,CAAC,OAAO,CAAC;CAkB5B"}

package/dist/packages/client/src/createTRPCClient.d.ts

@@ -0,0 +1,7 @@
+import type { AnyRouter } from '@trpc/server';
+import { TRPCClient as Client, CreateTRPCClientOptions } from './internals/TRPCClient';
+export declare function createTRPCClient<TRouter extends AnyRouter>(opts: CreateTRPCClientOptions<TRouter>): Client<TRouter>;
+export type { CreateTRPCClientOptions } from './internals/TRPCClient';
+export declare type TRPCClient<TRouter extends AnyRouter> = Client<TRouter>;
+export type { TRPCRequestOptions } from './internals/TRPCClient';
+//# sourceMappingURL=createTRPCClient.d.ts.map

package/dist/packages/client/src/createTRPCClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTRPCClient.d.ts","sourceRoot":"","sources":["../../../../src/createTRPCClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EACL,UAAU,IAAI,MAAM,EACpB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,SAAS,EACxD,IAAI,EAAE,uBAAuB,CAAC,OAAO,CAAC,mBAGvC;AAED,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEtE,oBAAY,UAAU,CAAC,OAAO,SAAS,SAAS,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;AAEpE,YAAY,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/packages/client/src/getFetch.d.ts

@@ -0,0 +1,2 @@
+export declare function getFetch(f?: typeof fetch): typeof fetch;
+//# sourceMappingURL=getFetch.d.ts.map

package/dist/packages/client/src/getFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFetch.d.ts","sourceRoot":"","sources":["../../../../src/getFetch.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,GAAG,OAAO,KAAK,CAYvD"}

package/dist/packages/client/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './createTRPCClient';
+export * from './getFetch';
+export * from './links/core';
+export * from './TRPCClientError';
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/client/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC"}

package/dist/packages/client/src/internals/TRPCAbortError.d.ts

@@ -0,0 +1,4 @@
+export declare class TRPCAbortError extends Error {
+    constructor();
+}
+//# sourceMappingURL=TRPCAbortError.d.ts.map

package/dist/packages/client/src/internals/TRPCAbortError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRPCAbortError.d.ts","sourceRoot":"","sources":["../../../../../src/internals/TRPCAbortError.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAe,SAAQ,KAAK;;CAMxC"}