@trpc/next 11.0.0-alpha-tmp-export-from-main.213 → 11.0.0-alpha-tmp-export-from-main.217

package/dist/createTRPCNext.mjs

@@ -0,0 +1,36 @@
+import { createFlatProxy } from '@trpc/core';
+import { createRootHooks, createReactQueryUtils, createReactDecoration } from '@trpc/react-query/shared';
+import { useMemo } from 'react';
+import { withTRPC } from './withTRPC.mjs';
+
+/* istanbul ignore file -- @preserve */ // We're testing this through E2E-testing
+function createTRPCNext(opts) {
+    const hooks = createRootHooks(opts);
+    // TODO: maybe set TSSRContext to `never` when using `WithTRPCNoSSROptions`
+    const _withTRPC = withTRPC(opts);
+    return createFlatProxy((key)=>{
+        if (key === 'useContext' || key === 'useUtils') {
+            return ()=>{
+                const context = hooks.useUtils();
+                // create a stable reference of the utils context
+                return useMemo(()=>{
+                    return createReactQueryUtils(context);
+                }, [
+                    context
+                ]);
+            };
+        }
+        if (key === 'useQueries') {
+            return hooks.useQueries;
+        }
+        if (key === 'useSuspenseQueries') {
+            return hooks.useSuspenseQueries;
+        }
+        if (key === 'withTRPC') {
+            return _withTRPC;
+        }
+        return createReactDecoration(key, hooks);
+    });
+}
+
+export { createTRPCNext };

package/dist/index.js

@@ -1,234 +1,9 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var withTRPC = require('./withTRPC.js');
+var createTRPCNext = require('./createTRPCNext.js');
 
-var reactQuery = require('@tanstack/react-query');
-var client = require('@trpc/client');
-var shared = require('@trpc/react-query/shared');
-var React = require('react');
-var core = require('@trpc/core');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function transformQueryOrMutationCacheErrors(result) {
-    const error = result.state.error;
-    if (error instanceof Error && error.name === 'TRPCClientError') {
-        const newError = {
-            message: error.message,
-            data: error.data,
-            shape: error.shape
-        };
-        return {
-            ...result,
-            state: {
-                ...result.state,
-                error: newError
-            }
-        };
-    }
-    return result;
-}
-function withTRPC(opts) {
-    const { config: getClientConfig  } = opts;
-    return (AppOrPage)=>{
-        const trpc = shared.createRootHooks(opts);
-        const WithTRPC = (props)=>{
-            const [prepassProps] = React.useState(()=>{
-                if (props.trpc) {
-                    return props.trpc;
-                }
-                const config = getClientConfig({});
-                const queryClient = shared.getQueryClient(config);
-                const trpcClient = trpc.createClient(config);
-                return {
-                    abortOnUnmount: config.abortOnUnmount,
-                    queryClient,
-                    trpcClient,
-                    ssrState: opts.ssr ? 'mounting' : false,
-                    ssrContext: null
-                };
-            });
-            const { queryClient , trpcClient , ssrState , ssrContext  } = prepassProps;
-            // allow normal components to be wrapped, not just app/pages
-            const hydratedState = trpc.useDehydratedState(trpcClient, props.pageProps?.trpcState);
-            return /*#__PURE__*/ React__default["default"].createElement(trpc.Provider, {
-                abortOnUnmount: prepassProps.abortOnUnmount ?? false,
-                client: trpcClient,
-                queryClient: queryClient,
-                ssrState: ssrState,
-                ssrContext: ssrContext
-            }, /*#__PURE__*/ React__default["default"].createElement(reactQuery.QueryClientProvider, {
-                client: queryClient
-            }, /*#__PURE__*/ React__default["default"].createElement(reactQuery.HydrationBoundary, {
-                state: hydratedState
-            }, /*#__PURE__*/ React__default["default"].createElement(AppOrPage, Object.assign({}, props)))));
-        };
-        if (AppOrPage.getInitialProps ?? opts.ssr) {
-            WithTRPC.getInitialProps = async (appOrPageCtx)=>{
-                const shouldSsr = async ()=>{
-                    if (typeof opts.ssr === 'function') {
-                        if (typeof window !== 'undefined') {
-                            return false;
-                        }
-                        try {
-                            return await opts.ssr({
-                                ctx: appOrPageCtx.ctx
-                            });
-                        } catch (e) {
-                            return false;
-                        }
-                    }
-                    return opts.ssr;
-                };
-                const ssr = await shouldSsr();
-                const AppTree = appOrPageCtx.AppTree;
-                // Determine if we are wrapping an App component or a Page component.
-                const isApp = !!appOrPageCtx.Component;
-                const ctx = isApp ? appOrPageCtx.ctx : appOrPageCtx;
-                // Run the wrapped component's getInitialProps function.
-                let pageProps = {};
-                if (AppOrPage.getInitialProps) {
-                    const originalProps = await AppOrPage.getInitialProps(appOrPageCtx);
-                    const originalPageProps = isApp ? originalProps.pageProps ?? {} : originalProps;
-                    pageProps = {
-                        ...originalPageProps,
-                        ...pageProps
-                    };
-                }
-                const getAppTreeProps = (props)=>isApp ? {
-                        pageProps: props
-                    } : props;
-                if (typeof window !== 'undefined' || !ssr) {
-                    return getAppTreeProps(pageProps);
-                }
-                const config = getClientConfig({
-                    ctx
-                });
-                const trpcClient = client.createTRPCUntypedClient(config);
-                const queryClient = shared.getQueryClient(config);
-                const trpcProp = {
-                    config,
-                    trpcClient,
-                    queryClient,
-                    ssrState: 'prepass',
-                    ssrContext: ctx
-                };
-                const prepassProps = {
-                    pageProps,
-                    trpc: trpcProp
-                };
-                const reactDomServer = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('react-dom/server')); });
-                // Run the prepass step on AppTree. This will run all trpc queries on the server.
-                // multiple prepass ensures that we can do batching on the server
-                while(true){
-                    // render full tree
-                    reactDomServer.renderToString(/*#__PURE__*/ React.createElement(AppTree, prepassProps));
-                    if (!queryClient.isFetching()) {
-                        break;
-                    }
-                    // wait until the query cache has settled it's promises
-                    await new Promise((resolve)=>{
-                        const unsub = queryClient.getQueryCache().subscribe((event)=>{
-                            if (event?.query.getObserversCount() === 0) {
-                                resolve();
-                                unsub();
-                            }
-                        });
-                    });
-                }
-                const dehydratedCache = reactQuery.dehydrate(queryClient, {
-                    shouldDehydrateQuery (query) {
-                        // filter out queries that are marked as trpc: { ssr: false } or are not enabled, but make sure errors are dehydrated
-                        const isExcludedFromSSr = query.state.fetchStatus === 'idle' && query.state.status === 'pending';
-                        return !isExcludedFromSSr;
-                    }
-                });
-                // since error instances can't be serialized, let's make them into `TRPCClientErrorLike`-objects
-                const dehydratedCacheWithErrors = {
-                    ...dehydratedCache,
-                    queries: dehydratedCache.queries.map(transformQueryOrMutationCacheErrors),
-                    mutations: dehydratedCache.mutations.map(transformQueryOrMutationCacheErrors)
-                };
-                // dehydrate query client's state and add it to the props
-                pageProps['trpcState'] = trpcClient.runtime.combinedTransformer.output.serialize(dehydratedCacheWithErrors);
-                const appTreeProps = getAppTreeProps(pageProps);
-                if ('responseMeta' in opts) {
-                    const meta = opts.responseMeta?.({
-                        ctx,
-                        clientErrors: [
-                            ...dehydratedCache.queries,
-                            ...dehydratedCache.mutations
-                        ].map((v)=>v.state.error).flatMap((err)=>err instanceof Error && err.name === 'TRPCClientError' ? [
-                                err
-                            ] : [])
-                    }) ?? {};
-                    for (const [key, value] of Object.entries(meta.headers ?? {})){
-                        if (typeof value === 'string') {
-                            ctx.res?.setHeader(key, value);
-                        }
-                    }
-                    if (meta.status && ctx.res) {
-                        ctx.res.statusCode = meta.status;
-                    }
-                }
-                return appTreeProps;
-            };
-        }
-        const displayName = AppOrPage.displayName ?? AppOrPage.name ?? 'Component';
-        WithTRPC.displayName = `withTRPC(${displayName})`;
-        return WithTRPC;
-    };
-}
-
-/* istanbul ignore file -- @preserve */ // We're testing this through E2E-testing
-function createTRPCNext(opts) {
-    const hooks = shared.createRootHooks(opts);
-    // TODO: maybe set TSSRContext to `never` when using `WithTRPCNoSSROptions`
-    const _withTRPC = withTRPC(opts);
-    return core.createFlatProxy((key)=>{
-        if (key === 'useContext' || key === 'useUtils') {
-            return ()=>{
-                const context = hooks.useUtils();
-                // create a stable reference of the utils context
-                return React.useMemo(()=>{
-                    return shared.createReactQueryUtils(context);
-                }, [
-                    context
-                ]);
-            };
-        }
-        if (key === 'useQueries') {
-            return hooks.useQueries;
-        }
-        if (key === 'useSuspenseQueries') {
-            return hooks.useSuspenseQueries;
-        }
-        if (key === 'withTRPC') {
-            return _withTRPC;
-        }
-        return shared.createReactDecoration(key, hooks);
-    });
-}
-
-exports.createTRPCNext = createTRPCNext;
-exports.withTRPC = withTRPC;
+exports.withTRPC = withTRPC.withTRPC;
+exports.createTRPCNext = createTRPCNext.createTRPCNext;

package/dist/index.mjs

@@ -1,207 +1,2 @@
-import { dehydrate, QueryClientProvider, HydrationBoundary } from '@tanstack/react-query';
-import { createTRPCUntypedClient } from '@trpc/client';
-import { createRootHooks, getQueryClient, createReactQueryUtils, createReactDecoration } from '@trpc/react-query/shared';
-import React, { createElement, useState, useMemo } from 'react';
-import { createFlatProxy } from '@trpc/core';
-
-function transformQueryOrMutationCacheErrors(result) {
-    const error = result.state.error;
-    if (error instanceof Error && error.name === 'TRPCClientError') {
-        const newError = {
-            message: error.message,
-            data: error.data,
-            shape: error.shape
-        };
-        return {
-            ...result,
-            state: {
-                ...result.state,
-                error: newError
-            }
-        };
-    }
-    return result;
-}
-function withTRPC(opts) {
-    const { config: getClientConfig  } = opts;
-    return (AppOrPage)=>{
-        const trpc = createRootHooks(opts);
-        const WithTRPC = (props)=>{
-            const [prepassProps] = useState(()=>{
-                if (props.trpc) {
-                    return props.trpc;
-                }
-                const config = getClientConfig({});
-                const queryClient = getQueryClient(config);
-                const trpcClient = trpc.createClient(config);
-                return {
-                    abortOnUnmount: config.abortOnUnmount,
-                    queryClient,
-                    trpcClient,
-                    ssrState: opts.ssr ? 'mounting' : false,
-                    ssrContext: null
-                };
-            });
-            const { queryClient , trpcClient , ssrState , ssrContext  } = prepassProps;
-            // allow normal components to be wrapped, not just app/pages
-            const hydratedState = trpc.useDehydratedState(trpcClient, props.pageProps?.trpcState);
-            return /*#__PURE__*/ React.createElement(trpc.Provider, {
-                abortOnUnmount: prepassProps.abortOnUnmount ?? false,
-                client: trpcClient,
-                queryClient: queryClient,
-                ssrState: ssrState,
-                ssrContext: ssrContext
-            }, /*#__PURE__*/ React.createElement(QueryClientProvider, {
-                client: queryClient
-            }, /*#__PURE__*/ React.createElement(HydrationBoundary, {
-                state: hydratedState
-            }, /*#__PURE__*/ React.createElement(AppOrPage, Object.assign({}, props)))));
-        };
-        if (AppOrPage.getInitialProps ?? opts.ssr) {
-            WithTRPC.getInitialProps = async (appOrPageCtx)=>{
-                const shouldSsr = async ()=>{
-                    if (typeof opts.ssr === 'function') {
-                        if (typeof window !== 'undefined') {
-                            return false;
-                        }
-                        try {
-                            return await opts.ssr({
-                                ctx: appOrPageCtx.ctx
-                            });
-                        } catch (e) {
-                            return false;
-                        }
-                    }
-                    return opts.ssr;
-                };
-                const ssr = await shouldSsr();
-                const AppTree = appOrPageCtx.AppTree;
-                // Determine if we are wrapping an App component or a Page component.
-                const isApp = !!appOrPageCtx.Component;
-                const ctx = isApp ? appOrPageCtx.ctx : appOrPageCtx;
-                // Run the wrapped component's getInitialProps function.
-                let pageProps = {};
-                if (AppOrPage.getInitialProps) {
-                    const originalProps = await AppOrPage.getInitialProps(appOrPageCtx);
-                    const originalPageProps = isApp ? originalProps.pageProps ?? {} : originalProps;
-                    pageProps = {
-                        ...originalPageProps,
-                        ...pageProps
-                    };
-                }
-                const getAppTreeProps = (props)=>isApp ? {
-                        pageProps: props
-                    } : props;
-                if (typeof window !== 'undefined' || !ssr) {
-                    return getAppTreeProps(pageProps);
-                }
-                const config = getClientConfig({
-                    ctx
-                });
-                const trpcClient = createTRPCUntypedClient(config);
-                const queryClient = getQueryClient(config);
-                const trpcProp = {
-                    config,
-                    trpcClient,
-                    queryClient,
-                    ssrState: 'prepass',
-                    ssrContext: ctx
-                };
-                const prepassProps = {
-                    pageProps,
-                    trpc: trpcProp
-                };
-                const reactDomServer = await import('react-dom/server');
-                // Run the prepass step on AppTree. This will run all trpc queries on the server.
-                // multiple prepass ensures that we can do batching on the server
-                while(true){
-                    // render full tree
-                    reactDomServer.renderToString(/*#__PURE__*/ createElement(AppTree, prepassProps));
-                    if (!queryClient.isFetching()) {
-                        break;
-                    }
-                    // wait until the query cache has settled it's promises
-                    await new Promise((resolve)=>{
-                        const unsub = queryClient.getQueryCache().subscribe((event)=>{
-                            if (event?.query.getObserversCount() === 0) {
-                                resolve();
-                                unsub();
-                            }
-                        });
-                    });
-                }
-                const dehydratedCache = dehydrate(queryClient, {
-                    shouldDehydrateQuery (query) {
-                        // filter out queries that are marked as trpc: { ssr: false } or are not enabled, but make sure errors are dehydrated
-                        const isExcludedFromSSr = query.state.fetchStatus === 'idle' && query.state.status === 'pending';
-                        return !isExcludedFromSSr;
-                    }
-                });
-                // since error instances can't be serialized, let's make them into `TRPCClientErrorLike`-objects
-                const dehydratedCacheWithErrors = {
-                    ...dehydratedCache,
-                    queries: dehydratedCache.queries.map(transformQueryOrMutationCacheErrors),
-                    mutations: dehydratedCache.mutations.map(transformQueryOrMutationCacheErrors)
-                };
-                // dehydrate query client's state and add it to the props
-                pageProps['trpcState'] = trpcClient.runtime.combinedTransformer.output.serialize(dehydratedCacheWithErrors);
-                const appTreeProps = getAppTreeProps(pageProps);
-                if ('responseMeta' in opts) {
-                    const meta = opts.responseMeta?.({
-                        ctx,
-                        clientErrors: [
-                            ...dehydratedCache.queries,
-                            ...dehydratedCache.mutations
-                        ].map((v)=>v.state.error).flatMap((err)=>err instanceof Error && err.name === 'TRPCClientError' ? [
-                                err
-                            ] : [])
-                    }) ?? {};
-                    for (const [key, value] of Object.entries(meta.headers ?? {})){
-                        if (typeof value === 'string') {
-                            ctx.res?.setHeader(key, value);
-                        }
-                    }
-                    if (meta.status && ctx.res) {
-                        ctx.res.statusCode = meta.status;
-                    }
-                }
-                return appTreeProps;
-            };
-        }
-        const displayName = AppOrPage.displayName ?? AppOrPage.name ?? 'Component';
-        WithTRPC.displayName = `withTRPC(${displayName})`;
-        return WithTRPC;
-    };
-}
-
-/* istanbul ignore file -- @preserve */ // We're testing this through E2E-testing
-function createTRPCNext(opts) {
-    const hooks = createRootHooks(opts);
-    // TODO: maybe set TSSRContext to `never` when using `WithTRPCNoSSROptions`
-    const _withTRPC = withTRPC(opts);
-    return createFlatProxy((key)=>{
-        if (key === 'useContext' || key === 'useUtils') {
-            return ()=>{
-                const context = hooks.useUtils();
-                // create a stable reference of the utils context
-                return useMemo(()=>{
-                    return createReactQueryUtils(context);
-                }, [
-                    context
-                ]);
-            };
-        }
-        if (key === 'useQueries') {
-            return hooks.useQueries;
-        }
-        if (key === 'useSuspenseQueries') {
-            return hooks.useSuspenseQueries;
-        }
-        if (key === 'withTRPC') {
-            return _withTRPC;
-        }
-        return createReactDecoration(key, hooks);
-    });
-}
-
-export { createTRPCNext, withTRPC };
+export { withTRPC } from './withTRPC.mjs';
+export { createTRPCNext } from './createTRPCNext.mjs';

package/dist/withTRPC.js

@@ -0,0 +1,178 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var client = require('@trpc/client');
+var shared = require('@trpc/react-query/shared');
+var React = require('react');
+
+function transformQueryOrMutationCacheErrors(result) {
+    const error = result.state.error;
+    if (error instanceof Error && error.name === 'TRPCClientError') {
+        const newError = {
+            message: error.message,
+            data: error.data,
+            shape: error.shape
+        };
+        return {
+            ...result,
+            state: {
+                ...result.state,
+                error: newError
+            }
+        };
+    }
+    return result;
+}
+function withTRPC(opts) {
+    const { config: getClientConfig  } = opts;
+    return (AppOrPage)=>{
+        const trpc = shared.createRootHooks(opts);
+        const WithTRPC = (props)=>{
+            const [prepassProps] = React.useState(()=>{
+                if (props.trpc) {
+                    return props.trpc;
+                }
+                const config = getClientConfig({});
+                const queryClient = shared.getQueryClient(config);
+                const trpcClient = trpc.createClient(config);
+                return {
+                    abortOnUnmount: config.abortOnUnmount,
+                    queryClient,
+                    trpcClient,
+                    ssrState: opts.ssr ? 'mounting' : false,
+                    ssrContext: null
+                };
+            });
+            const { queryClient , trpcClient , ssrState , ssrContext  } = prepassProps;
+            // allow normal components to be wrapped, not just app/pages
+            const hydratedState = trpc.useDehydratedState(trpcClient, props.pageProps?.trpcState);
+            return /*#__PURE__*/ React.createElement(trpc.Provider, {
+                abortOnUnmount: prepassProps.abortOnUnmount ?? false,
+                client: trpcClient,
+                queryClient: queryClient,
+                ssrState: ssrState,
+                ssrContext: ssrContext
+            }, /*#__PURE__*/ React.createElement(reactQuery.QueryClientProvider, {
+                client: queryClient
+            }, /*#__PURE__*/ React.createElement(reactQuery.HydrationBoundary, {
+                state: hydratedState
+            }, /*#__PURE__*/ React.createElement(AppOrPage, Object.assign({}, props)))));
+        };
+        if (AppOrPage.getInitialProps ?? opts.ssr) {
+            WithTRPC.getInitialProps = async (appOrPageCtx)=>{
+                const shouldSsr = async ()=>{
+                    if (typeof opts.ssr === 'function') {
+                        if (typeof window !== 'undefined') {
+                            return false;
+                        }
+                        try {
+                            return await opts.ssr({
+                                ctx: appOrPageCtx.ctx
+                            });
+                        } catch (e) {
+                            return false;
+                        }
+                    }
+                    return opts.ssr;
+                };
+                const ssr = await shouldSsr();
+                const AppTree = appOrPageCtx.AppTree;
+                // Determine if we are wrapping an App component or a Page component.
+                const isApp = !!appOrPageCtx.Component;
+                const ctx = isApp ? appOrPageCtx.ctx : appOrPageCtx;
+                // Run the wrapped component's getInitialProps function.
+                let pageProps = {};
+                if (AppOrPage.getInitialProps) {
+                    const originalProps = await AppOrPage.getInitialProps(appOrPageCtx);
+                    const originalPageProps = isApp ? originalProps.pageProps ?? {} : originalProps;
+                    pageProps = {
+                        ...originalPageProps,
+                        ...pageProps
+                    };
+                }
+                const getAppTreeProps = (props)=>isApp ? {
+                        pageProps: props
+                    } : props;
+                if (typeof window !== 'undefined' || !ssr) {
+                    return getAppTreeProps(pageProps);
+                }
+                const config = getClientConfig({
+                    ctx
+                });
+                const trpcClient = client.createTRPCUntypedClient(config);
+                const queryClient = shared.getQueryClient(config);
+                const trpcProp = {
+                    config,
+                    trpcClient,
+                    queryClient,
+                    ssrState: 'prepass',
+                    ssrContext: ctx
+                };
+                const prepassProps = {
+                    pageProps,
+                    trpc: trpcProp
+                };
+                const reactDomServer = await import('react-dom/server');
+                // Run the prepass step on AppTree. This will run all trpc queries on the server.
+                // multiple prepass ensures that we can do batching on the server
+                while(true){
+                    // render full tree
+                    reactDomServer.renderToString(/*#__PURE__*/ React.createElement(AppTree, prepassProps));
+                    if (!queryClient.isFetching()) {
+                        break;
+                    }
+                    // wait until the query cache has settled it's promises
+                    await new Promise((resolve)=>{
+                        const unsub = queryClient.getQueryCache().subscribe((event)=>{
+                            if (event?.query.getObserversCount() === 0) {
+                                resolve();
+                                unsub();
+                            }
+                        });
+                    });
+                }
+                const dehydratedCache = reactQuery.dehydrate(queryClient, {
+                    shouldDehydrateQuery (query) {
+                        // filter out queries that are marked as trpc: { ssr: false } or are not enabled, but make sure errors are dehydrated
+                        const isExcludedFromSSr = query.state.fetchStatus === 'idle' && query.state.status === 'pending';
+                        return !isExcludedFromSSr;
+                    }
+                });
+                // since error instances can't be serialized, let's make them into `TRPCClientErrorLike`-objects
+                const dehydratedCacheWithErrors = {
+                    ...dehydratedCache,
+                    queries: dehydratedCache.queries.map(transformQueryOrMutationCacheErrors),
+                    mutations: dehydratedCache.mutations.map(transformQueryOrMutationCacheErrors)
+                };
+                // dehydrate query client's state and add it to the props
+                pageProps['trpcState'] = trpcClient.runtime.combinedTransformer.output.serialize(dehydratedCacheWithErrors);
+                const appTreeProps = getAppTreeProps(pageProps);
+                if ('responseMeta' in opts) {
+                    const meta = opts.responseMeta?.({
+                        ctx,
+                        clientErrors: [
+                            ...dehydratedCache.queries,
+                            ...dehydratedCache.mutations
+                        ].map((v)=>v.state.error).flatMap((err)=>err instanceof Error && err.name === 'TRPCClientError' ? [
+                                err
+                            ] : [])
+                    }) ?? {};
+                    for (const [key, value] of Object.entries(meta.headers ?? {})){
+                        if (typeof value === 'string') {
+                            ctx.res?.setHeader(key, value);
+                        }
+                    }
+                    if (meta.status && ctx.res) {
+                        ctx.res.statusCode = meta.status;
+                    }
+                }
+                return appTreeProps;
+            };
+        }
+        const displayName = AppOrPage.displayName ?? AppOrPage.name ?? 'Component';
+        WithTRPC.displayName = `withTRPC(${displayName})`;
+        return WithTRPC;
+    };
+}
+
+exports.withTRPC = withTRPC;