@trpc/react-query 10.0.0-proxy-beta.21

package/dist/createHooksInternal-e8214d72.js

@@ -0,0 +1,400 @@
+'use strict';
+
+var shared = require('@trpc/server/shared');
+var reactQuery = require('@tanstack/react-query');
+var client = require('@trpc/client');
+var React = require('react');
+var getArrayQueryKey = require('./getArrayQueryKey-a2092b3c.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+/**
+ * We treat `undefined` as an input the same as omitting an `input`
+ * https://github.com/trpc/trpc/issues/2290
+ */ function getQueryKey(path, input) {
+    return input === undefined ? [
+        path
+    ] : [
+        path,
+        input
+    ];
+}
+
+/**
+ * Create proxy for decorating procedures
+ * @internal
+ */ function createReactProxyDecoration(name, hooks) {
+    return shared.createRecursiveProxy((opts)=>{
+        const args = opts.args;
+        const pathCopy = [
+            name,
+            ...opts.path
+        ];
+        // The last arg is for instance `.useMutation` or `.useQuery()`
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lastArg = pathCopy.pop();
+        // The `path` ends up being something like `post.byId`
+        const path = pathCopy.join('.');
+        if (lastArg === 'useMutation') {
+            return hooks[lastArg](path, ...args);
+        }
+        const [input, ...rest] = args;
+        const queryKey = getQueryKey(path, input);
+        return hooks[lastArg](queryKey, ...rest);
+    });
+}
+
+const contextProps = [
+    'client',
+    'ssrContext',
+    'ssrState',
+    'abortOnUnmount'
+];
+const TRPCContext = /*#__PURE__*/ React.createContext(null);
+
+/**
+ * @internal
+ */ function createReactQueryUtilsProxy(context) {
+    return shared.createFlatProxy((key)=>{
+        const contextName = key;
+        if (contextProps.includes(contextName)) {
+            return context[contextName];
+        }
+        return shared.createRecursiveProxy(({ path , args  })=>{
+            const pathCopy = [
+                key,
+                ...path
+            ];
+            const utilName = pathCopy.pop();
+            const fullPath = pathCopy.join('.');
+            const getOpts = (name)=>{
+                if ([
+                    'setData',
+                    'setInfiniteData'
+                ].includes(name)) {
+                    const [updater, input, ...rest] = args;
+                    const queryKey = getQueryKey(fullPath, input);
+                    return {
+                        queryKey,
+                        updater,
+                        rest
+                    };
+                }
+                const [input1, ...rest1] = args;
+                const queryKey1 = getQueryKey(fullPath, input1);
+                return {
+                    queryKey: queryKey1,
+                    rest: rest1
+                };
+            };
+            const { queryKey , rest , updater  } = getOpts(utilName);
+            const contextMap = {
+                fetch: ()=>context.fetchQuery(queryKey, ...rest),
+                fetchInfinite: ()=>context.fetchInfiniteQuery(queryKey, ...rest),
+                prefetch: ()=>context.prefetchQuery(queryKey, ...rest),
+                prefetchInfinite: ()=>context.prefetchInfiniteQuery(queryKey, ...rest),
+                invalidate: ()=>context.invalidateQueries(queryKey, ...rest),
+                refetch: ()=>context.refetchQueries(queryKey, ...rest),
+                cancel: ()=>context.cancelQuery(queryKey, ...rest),
+                setData: ()=>context.setQueryData(queryKey, updater, ...rest),
+                setInfiniteData: ()=>context.setInfiniteQueryData(queryKey, updater, ...rest),
+                getData: ()=>context.getQueryData(queryKey),
+                getInfiniteData: ()=>context.getInfiniteQueryData(queryKey)
+            };
+            return contextMap[utilName]();
+        });
+    });
+}
+
+function getClientArgs(pathAndInput, opts) {
+    const [path, input] = pathAndInput;
+    return [
+        path,
+        input,
+        opts?.trpc
+    ];
+}
+/**
+ * Makes a stable reference of the `trpc` prop
+ */ function useHookResult(value) {
+    const ref = React.useRef(value);
+    ref.current.path = value.path;
+    return ref.current;
+}
+/**
+ * Create strongly typed react hooks
+ * @internal
+ */ function createHooksInternal(config) {
+    const mutationSuccessOverride = config?.unstable_overrides?.useMutation?.onSuccess ?? ((options)=>options.originalFn());
+    const Context = TRPCContext;
+    const createClient = (opts)=>{
+        return client.createTRPCClient(opts);
+    };
+    const TRPCProvider = (props)=>{
+        const { abortOnUnmount =false , client , queryClient , ssrContext  } = props;
+        const [ssrState, setSSRState] = React.useState(props.ssrState ?? false);
+        React.useEffect(()=>{
+            // Only updating state to `mounted` if we are using SSR.
+            // This makes it so we don't have an unnecessary re-render when opting out of SSR.
+            setSSRState((state)=>state ? 'mounted' : false);
+        }, []);
+        return /*#__PURE__*/ React__default["default"].createElement(Context.Provider, {
+            value: {
+                abortOnUnmount,
+                queryClient,
+                client,
+                ssrContext: ssrContext || null,
+                ssrState,
+                fetchQuery: React.useCallback((pathAndInput, opts)=>{
+                    return queryClient.fetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                }, [
+                    client,
+                    queryClient
+                ]),
+                fetchInfiniteQuery: React.useCallback((pathAndInput, opts)=>{
+                    return queryClient.fetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), ({ pageParam  })=>{
+                        const [path, input] = pathAndInput;
+                        const actualInput = {
+                            ...input,
+                            cursor: pageParam
+                        };
+                        return client.query(...getClientArgs([
+                            path,
+                            actualInput
+                        ], opts));
+                    }, opts);
+                }, [
+                    client,
+                    queryClient
+                ]),
+                prefetchQuery: React.useCallback((pathAndInput, opts)=>{
+                    return queryClient.prefetchQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), ()=>client.query(...getClientArgs(pathAndInput, opts)), opts);
+                }, [
+                    client,
+                    queryClient
+                ]),
+                prefetchInfiniteQuery: React.useCallback((pathAndInput, opts)=>{
+                    return queryClient.prefetchInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), ({ pageParam  })=>{
+                        const [path, input] = pathAndInput;
+                        const actualInput = {
+                            ...input,
+                            cursor: pageParam
+                        };
+                        return client.query(...getClientArgs([
+                            path,
+                            actualInput
+                        ], opts));
+                    }, opts);
+                }, [
+                    client,
+                    queryClient
+                ]),
+                invalidateQueries: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.invalidateQueries(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ]),
+                refetchQueries: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.refetchQueries(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ]),
+                cancelQuery: React.useCallback((pathAndInput)=>{
+                    return queryClient.cancelQueries(getArrayQueryKey.getArrayQueryKey(pathAndInput));
+                }, [
+                    queryClient
+                ]),
+                setQueryData: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.setQueryData(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ]),
+                getQueryData: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.getQueryData(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ]),
+                setInfiniteQueryData: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.setQueryData(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ]),
+                getInfiniteQueryData: React.useCallback((...args)=>{
+                    const [queryKey, ...rest] = args;
+                    return queryClient.getQueryData(getArrayQueryKey.getArrayQueryKey(queryKey), ...rest);
+                }, [
+                    queryClient
+                ])
+            }
+        }, props.children);
+    };
+    function useContext() {
+        return React__default["default"].useContext(Context);
+    }
+    /**
+   * Hack to make sure errors return `status`='error` when doing SSR
+   * @link https://github.com/trpc/trpc/pull/1645
+   */ function useSSRQueryOptionsIfNeeded(pathAndInput, opts) {
+        const { queryClient , ssrState  } = useContext();
+        return ssrState && ssrState !== 'mounted' && queryClient.getQueryCache().find(getArrayQueryKey.getArrayQueryKey(pathAndInput))?.state.status === 'error' ? {
+            retryOnMount: false,
+            ...opts
+        } : opts;
+    }
+    function useQuery(pathAndInput, opts) {
+        const { abortOnUnmount , client , ssrState , queryClient , prefetchQuery  } = useContext();
+        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && opts?.enabled !== false && !queryClient.getQueryCache().find(getArrayQueryKey.getArrayQueryKey(pathAndInput))) {
+            void prefetchQuery(pathAndInput, opts);
+        }
+        const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, opts);
+        // request option should take priority over global
+        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
+        const hook = reactQuery.useQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), (queryFunctionContext)=>{
+            const actualOpts = {
+                ...ssrOpts,
+                trpc: {
+                    ...ssrOpts?.trpc,
+                    ...shouldAbortOnUnmount ? {
+                        signal: queryFunctionContext.signal
+                    } : {}
+                }
+            };
+            return client.query(...getClientArgs(pathAndInput, actualOpts));
+        }, ssrOpts);
+        hook.trpc = useHookResult({
+            path: pathAndInput[0]
+        });
+        return hook;
+    }
+    function useMutation(path, opts) {
+        const { client  } = useContext();
+        const queryClient = reactQuery.useQueryClient();
+        const hook = reactQuery.useMutation((input)=>{
+            const actualPath = Array.isArray(path) ? path[0] : path;
+            return client.mutation(...getClientArgs([
+                actualPath,
+                input
+            ], opts));
+        }, {
+            ...opts,
+            onSuccess (...args) {
+                const originalFn = ()=>opts?.onSuccess?.(...args);
+                return mutationSuccessOverride({
+                    originalFn,
+                    queryClient
+                });
+            }
+        });
+        hook.trpc = useHookResult({
+            path: Array.isArray(path) ? path[0] : path
+        });
+        return hook;
+    }
+    /* istanbul ignore next */ /**
+   * ⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️
+   *  **Experimental.** API might change without major version bump
+   * ⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠️⚠
+   */ function useSubscription(pathAndInput, opts) {
+        const enabled = opts?.enabled ?? true;
+        const queryKey = reactQuery.hashQueryKey(pathAndInput);
+        const { client  } = useContext();
+        return React.useEffect(()=>{
+            if (!enabled) {
+                return;
+            }
+            const [path, input] = pathAndInput;
+            let isStopped = false;
+            const subscription = client.subscription(path, input ?? undefined, {
+                onStarted: ()=>{
+                    if (!isStopped) {
+                        opts.onStarted?.();
+                    }
+                },
+                onData: (data)=>{
+                    if (!isStopped) {
+                        opts.onData(data);
+                    }
+                },
+                onError: (err)=>{
+                    if (!isStopped) {
+                        opts.onError?.(err);
+                    }
+                }
+            });
+            return ()=>{
+                isStopped = true;
+                subscription.unsubscribe();
+            };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [
+            queryKey,
+            enabled
+        ]);
+    }
+    function useInfiniteQuery(pathAndInput, opts) {
+        const [path, input] = pathAndInput;
+        const { client , ssrState , prefetchInfiniteQuery , queryClient , abortOnUnmount ,  } = useContext();
+        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && opts?.enabled !== false && !queryClient.getQueryCache().find(getArrayQueryKey.getArrayQueryKey(pathAndInput))) {
+            void prefetchInfiniteQuery(pathAndInput, opts);
+        }
+        const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, opts);
+        // request option should take priority over global
+        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
+        const hook = reactQuery.useInfiniteQuery(getArrayQueryKey.getArrayQueryKey(pathAndInput), (queryFunctionContext)=>{
+            const actualOpts = {
+                ...ssrOpts,
+                trpc: {
+                    ...ssrOpts?.trpc,
+                    ...shouldAbortOnUnmount ? {
+                        signal: queryFunctionContext.signal
+                    } : {}
+                }
+            };
+            const actualInput = {
+                ...input ?? {},
+                cursor: queryFunctionContext.pageParam
+            };
+            return client.query(...getClientArgs([
+                path,
+                actualInput
+            ], actualOpts));
+        }, ssrOpts);
+        hook.trpc = useHookResult({
+            path
+        });
+        return hook;
+    }
+    const useDehydratedState = (client, trpcState)=>{
+        const transformed = React.useMemo(()=>{
+            if (!trpcState) {
+                return trpcState;
+            }
+            return client.runtime.transformer.deserialize(trpcState);
+        }, [
+            trpcState,
+            client
+        ]);
+        return transformed;
+    };
+    return {
+        Provider: TRPCProvider,
+        createClient,
+        useContext,
+        useQuery,
+        useMutation,
+        useSubscription,
+        useDehydratedState,
+        useInfiniteQuery
+    };
+}
+
+exports.createHooksInternal = createHooksInternal;
+exports.createReactProxyDecoration = createReactProxyDecoration;
+exports.createReactQueryUtilsProxy = createReactQueryUtilsProxy;

package/dist/createTRPCReact.d.ts

@@ -0,0 +1,38 @@
+import { TRPCClientErrorLike } from '@trpc/client';
+import { AnyMutationProcedure, AnyProcedure, AnyQueryProcedure, AnyRouter, AnySubscriptionProcedure, ProcedureRouterRecord, inferProcedureInput, inferProcedureOutput } from '@trpc/server';
+import { inferObservableValue } from '@trpc/server/observable';
+import { CreateReactUtilsProxy } from './shared';
+import { CreateClient, CreateReactQueryHooks, TRPCProvider, UseDehydratedState, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCSubscriptionOptions } from './shared/hooks/createHooksInternal';
+import { CreateTRPCReactOptions } from './shared/types';
+/**
+ * @internal
+ */
+export declare type DecorateProcedure<TProcedure extends AnyProcedure, TPath extends string> = TProcedure extends AnyQueryProcedure ? {
+    useQuery: <TQueryFnData = inferProcedureOutput<TProcedure>, TData = inferProcedureOutput<TProcedure>>(input: inferProcedureInput<TProcedure>, opts?: UseTRPCQueryOptions<TPath, inferProcedureInput<TProcedure>, TQueryFnData, TData, TRPCClientErrorLike<TProcedure>>) => UseTRPCQueryResult<TData, TRPCClientErrorLike<TProcedure>>;
+} & (inferProcedureInput<TProcedure> extends {
+    cursor?: any;
+} ? {
+    useInfiniteQuery: <_TQueryFnData = inferProcedureOutput<TProcedure>, TData = inferProcedureOutput<TProcedure>>(input: Omit<inferProcedureInput<TProcedure>, 'cursor'>, opts?: UseTRPCInfiniteQueryOptions<TPath, inferProcedureInput<TProcedure>, TData, TRPCClientErrorLike<TProcedure>>) => UseTRPCInfiniteQueryResult<TData, TRPCClientErrorLike<TProcedure>>;
+} : {}) : TProcedure extends AnyMutationProcedure ? {
+    useMutation: <TContext = unknown>(opts?: UseTRPCMutationOptions<inferProcedureInput<TProcedure>, TRPCClientErrorLike<TProcedure>, inferProcedureOutput<TProcedure>, TContext>) => UseTRPCMutationResult<inferProcedureOutput<TProcedure>, TRPCClientErrorLike<TProcedure>, inferProcedureInput<TProcedure>, TContext>;
+} : TProcedure extends AnySubscriptionProcedure ? {
+    useSubscription: (input: inferProcedureInput<TProcedure>, opts?: UseTRPCSubscriptionOptions<inferObservableValue<inferProcedureOutput<TProcedure>>, TRPCClientErrorLike<TProcedure>>) => void;
+} : never;
+/**
+ * @internal
+ */
+export declare type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord, TPath extends string = ''> = {
+    [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record'], `${TPath}${TKey & string}.`> : TProcedures[TKey] extends AnyProcedure ? DecorateProcedure<TProcedures[TKey], `${TPath}${TKey & string}`> : never;
+};
+export declare type CreateTRPCReact<TRouter extends AnyRouter, TSSRContext> = {
+    useContext(): CreateReactUtilsProxy<TRouter, TSSRContext>;
+    Provider: TRPCProvider<TRouter, TSSRContext>;
+    createClient: CreateClient<TRouter>;
+    useDehydratedState: UseDehydratedState<TRouter>;
+} & DecoratedProcedureRecord<TRouter['_def']['record']>;
+/**
+ * @internal
+ */
+export declare function createHooksInternalProxy<TRouter extends AnyRouter, TSSRContext = unknown>(trpc: CreateReactQueryHooks<TRouter, TSSRContext>): CreateTRPCReact<TRouter, TSSRContext>;
+export declare function createTRPCReact<TRouter extends AnyRouter, TSSRContext = unknown>(opts?: CreateTRPCReactOptions<TRouter>): CreateTRPCReact<TRouter, TSSRContext>;
+//# sourceMappingURL=createTRPCReact.d.ts.map

package/dist/createTRPCReact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTRPCReact.d.ts","sourceRoot":"","sources":["../src/createTRPCReact.tsx"],"names":[],"mappings":"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"}

package/dist/getArrayQueryKey-062214e0.mjs

@@ -0,0 +1,19 @@
+/**
+ * To allow easy interactions with groups of related queries, such as
+ * invalidating all queries of a router, we use an array as the path when
+ * storing in tanstack query. This function converts from the `.` separated
+ * path passed around internally by both the legacy and proxy implementation.
+ * https://github.com/trpc/trpc/issues/2611
+ */ function getArrayQueryKey(queryKey) {
+    const queryKeyArrayed = Array.isArray(queryKey) ? queryKey : [
+        queryKey
+    ];
+    const [path, ...input] = queryKeyArrayed;
+    const arrayPath = typeof path !== 'string' || path === '' ? [] : path.split('.');
+    return [
+        arrayPath,
+        ...input
+    ];
+}
+
+export { getArrayQueryKey as g };

package/dist/getArrayQueryKey-a2092b3c.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * To allow easy interactions with groups of related queries, such as
+ * invalidating all queries of a router, we use an array as the path when
+ * storing in tanstack query. This function converts from the `.` separated
+ * path passed around internally by both the legacy and proxy implementation.
+ * https://github.com/trpc/trpc/issues/2611
+ */ function getArrayQueryKey(queryKey) {
+    const queryKeyArrayed = Array.isArray(queryKey) ? queryKey : [
+        queryKey
+    ];
+    const [path, ...input] = queryKeyArrayed;
+    const arrayPath = typeof path !== 'string' || path === '' ? [] : path.split('.');
+    return [
+        arrayPath,
+        ...input
+    ];
+}
+
+exports.getArrayQueryKey = getArrayQueryKey;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@trpc/client';
+export { createTRPCReact, type CreateTRPCReact } from './createTRPCReact';
+export { createReactQueryHooks } from './interop';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var client = require('@trpc/client');
+var shared = require('@trpc/server/shared');
+var React = require('react');
+var createHooksInternal = require('./createHooksInternal-e8214d72.js');
+require('@tanstack/react-query');
+require('./getArrayQueryKey-a2092b3c.js');
+
+/**
+ * @internal
+ */ function createHooksInternalProxy(trpc) {
+    return shared.createFlatProxy((key)=>{
+        if (key === 'useContext') {
+            return ()=>{
+                const context = trpc.useContext();
+                // create a stable reference of the utils context
+                return React.useMemo(()=>{
+                    return createHooksInternal.createReactQueryUtilsProxy(context);
+                }, [
+                    context
+                ]);
+            };
+        }
+        if (key in trpc) {
+            return trpc[key];
+        }
+        return createHooksInternal.createReactProxyDecoration(key, trpc);
+    });
+}
+function createTRPCReact(opts) {
+    const hooks = createHooksInternal.createHooksInternal(opts);
+    const proxy = createHooksInternalProxy(hooks);
+    return proxy;
+}
+
+// interop:
+/**
+ * @deprecated use `createTRPCReact` instead
+ */ function createReactQueryHooks() {
+    const trpc = createHooksInternal.createHooksInternal();
+    const proxy = createHooksInternalProxy(trpc);
+    return {
+        ...trpc,
+        proxy
+    };
+}
+
+exports.createReactQueryHooks = createReactQueryHooks;
+exports.createTRPCReact = createTRPCReact;
+Object.keys(client).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return client[k]; }
+  });
+});

package/dist/index.mjs

@@ -0,0 +1,47 @@
+export * from '@trpc/client';
+import { createFlatProxy } from '@trpc/server/shared';
+import { useMemo } from 'react';
+import { c as createHooksInternal, a as createReactQueryUtilsProxy, b as createReactProxyDecoration } from './createHooksInternal-b47ee704.mjs';
+import '@tanstack/react-query';
+import './getArrayQueryKey-062214e0.mjs';
+
+/**
+ * @internal
+ */ function createHooksInternalProxy(trpc) {
+    return createFlatProxy((key)=>{
+        if (key === 'useContext') {
+            return ()=>{
+                const context = trpc.useContext();
+                // create a stable reference of the utils context
+                return useMemo(()=>{
+                    return createReactQueryUtilsProxy(context);
+                }, [
+                    context
+                ]);
+            };
+        }
+        if (key in trpc) {
+            return trpc[key];
+        }
+        return createReactProxyDecoration(key, trpc);
+    });
+}
+function createTRPCReact(opts) {
+    const hooks = createHooksInternal(opts);
+    const proxy = createHooksInternalProxy(hooks);
+    return proxy;
+}
+
+// interop:
+/**
+ * @deprecated use `createTRPCReact` instead
+ */ function createReactQueryHooks() {
+    const trpc = createHooksInternal();
+    const proxy = createHooksInternalProxy(trpc);
+    return {
+        ...trpc,
+        proxy
+    };
+}
+
+export { createReactQueryHooks, createTRPCReact };