@trpc/react-query 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

package/dist/shared/hooks/createHooksInternal.js

@@ -1,542 +1,432 @@
-'use strict';
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey = require('../../internals/getQueryKey.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_internals_context = require('../../internals/context.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_shared_proxy_useQueriesProxy = require('../proxy/useQueriesProxy.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs = require('../../internals/getClientArgs.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult = require('../../internals/trpcResult.js');
+const require__Users_julius_dev_trpc_packages_react_query_src_utils_createUtilityFunctions = require('../../utils/createUtilityFunctions.js');
+const __trpc_client = require_rolldown_runtime.__toESM(require("@trpc/client"));
+const __tanstack_react_query = require_rolldown_runtime.__toESM(require("@tanstack/react-query"));
+const __trpc_server_unstable_core_do_not_import = require_rolldown_runtime.__toESM(require("@trpc/server/unstable-core-do-not-import"));
+const react = require_rolldown_runtime.__toESM(require("react"));
+const react_jsx_runtime = require_rolldown_runtime.__toESM(require("react/jsx-runtime"));
 
-var reactQuery = require('@tanstack/react-query');
-var client = require('@trpc/client');
-var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
-var React = require('react');
-var context = require('../../internals/context.js');
-var getClientArgs = require('../../internals/getClientArgs.js');
-var getQueryKey = require('../../internals/getQueryKey.js');
-var trpcResult = require('../../internals/trpcResult.js');
-var createUtilityFunctions = require('../../utils/createUtilityFunctions.js');
-var useQueriesProxy = require('../proxy/useQueriesProxy.js');
-
-function _interopNamespaceDefault(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__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
-
-const trackResult = (result, onTrackResult)=>{
-    const trackedResult = new Proxy(result, {
-        get (target, prop) {
-            onTrackResult(prop);
-            return target[prop];
-        }
-    });
-    return trackedResult;
+//#region src/shared/hooks/createHooksInternal.tsx
+const trackResult = (result, onTrackResult) => {
+	const trackedResult = new Proxy(result, { get(target, prop) {
+		onTrackResult(prop);
+		return target[prop];
+	} });
+	return trackedResult;
 };
 /**
- * @internal
- */ function createRootHooks(config) {
-    const mutationSuccessOverride = config?.overrides?.useMutation?.onSuccess ?? ((options)=>options.originalFn());
-    const Context = config?.context ?? context.TRPCContext;
-    const createClient = client.createTRPCClient;
-    const TRPCProvider = (props)=>{
-        const { abortOnUnmount = false, queryClient, ssrContext } = props;
-        const [ssrState, setSSRState] = React__namespace.useState(props.ssrState ?? false);
-        const client$1 = props.client instanceof client.TRPCUntypedClient ? props.client : client.getUntypedClient(props.client);
-        const fns = React__namespace.useMemo(()=>createUtilityFunctions.createUtilityFunctions({
-                client: client$1,
-                queryClient
-            }), [
-            client$1,
-            queryClient
-        ]);
-        const contextValue = React__namespace.useMemo(()=>({
-                abortOnUnmount,
-                queryClient,
-                client: client$1,
-                ssrContext: ssrContext ?? null,
-                ssrState,
-                ...fns
-            }), [
-            abortOnUnmount,
-            client$1,
-            fns,
-            queryClient,
-            ssrContext,
-            ssrState
-        ]);
-        React__namespace.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__namespace.createElement(Context.Provider, {
-            value: contextValue
-        }, props.children);
-    };
-    function useContext() {
-        const context = React__namespace.useContext(Context);
-        if (!context) {
-            throw new Error('Unable to find tRPC Context. Did you forget to wrap your App inside `withTRPC` HoC?');
-        }
-        return context;
-    }
-    /**
-   * Hack to make sure errors return `status`='error` when doing SSR
-   * @see https://github.com/trpc/trpc/pull/1645
-   */ function useSSRQueryOptionsIfNeeded(queryKey, opts) {
-        const { queryClient, ssrState } = useContext();
-        return ssrState && ssrState !== 'mounted' && queryClient.getQueryCache().find({
-            queryKey
-        })?.state.status === 'error' ? {
-            retryOnMount: false,
-            ...opts
-        } : opts;
-    }
-    function useQuery(path, input, opts) {
-        const context = useContext();
-        const { abortOnUnmount, client, ssrState, queryClient, prefetchQuery } = context;
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'query');
-        const defaultOpts = queryClient.getQueryDefaults(queryKey);
-        const isInputSkipToken = input === reactQuery.skipToken;
-        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !isInputSkipToken && !queryClient.getQueryCache().find({
-            queryKey
-        })) {
-            void prefetchQuery(queryKey, opts);
-        }
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts
-        });
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? abortOnUnmount;
-        const hook = reactQuery.useQuery({
-            ...ssrOpts,
-            queryKey: queryKey,
-            queryFn: isInputSkipToken ? input : async (queryFunctionContext)=>{
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {
-                            signal: null
-                        }
-                    }
-                };
-                const result = await client.query(...getClientArgs.getClientArgs(queryKey, actualOpts));
-                if (unstableCoreDoNotImport.isAsyncIterable(result)) {
-                    return trpcResult.buildQueryFromAsyncIterable(result, queryClient, queryKey);
-                }
-                return result;
-            }
-        }, queryClient);
-        hook.trpc = trpcResult.useHookResult({
-            path
-        });
-        return hook;
-    }
-    function usePrefetchQuery(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'query');
-        const isInputSkipToken = input === reactQuery.skipToken;
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
-        reactQuery.usePrefetchQuery({
-            ...opts,
-            queryKey: queryKey,
-            queryFn: isInputSkipToken ? input : (queryFunctionContext)=>{
-                const actualOpts = {
-                    trpc: {
-                        ...opts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {}
-                    }
-                };
-                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts));
-            }
-        });
-    }
-    function useSuspenseQuery(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'query');
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
-        const hook = reactQuery.useSuspenseQuery({
-            ...opts,
-            queryKey: queryKey,
-            queryFn: (queryFunctionContext)=>{
-                const actualOpts = {
-                    ...opts,
-                    trpc: {
-                        ...opts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {
-                            signal: null
-                        }
-                    }
-                };
-                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts));
-            }
-        }, context.queryClient);
-        hook.trpc = trpcResult.useHookResult({
-            path
-        });
-        return [
-            hook.data,
-            hook
-        ];
-    }
-    function useMutation(path, opts) {
-        const { client, queryClient } = useContext();
-        const mutationKey = getQueryKey.getMutationKeyInternal(path);
-        const defaultOpts = queryClient.defaultMutationOptions(queryClient.getMutationDefaults(mutationKey));
-        const hook = reactQuery.useMutation({
-            ...opts,
-            mutationKey: mutationKey,
-            mutationFn: (input)=>{
-                return client.mutation(...getClientArgs.getClientArgs([
-                    path,
-                    {
-                        input
-                    }
-                ], opts));
-            },
-            onSuccess (...args) {
-                const originalFn = ()=>opts?.onSuccess?.(...args) ?? defaultOpts?.onSuccess?.(...args);
-                return mutationSuccessOverride({
-                    originalFn,
-                    queryClient,
-                    meta: opts?.meta ?? defaultOpts?.meta ?? {}
-                });
-            }
-        }, queryClient);
-        hook.trpc = trpcResult.useHookResult({
-            path
-        });
-        return hook;
-    }
-    const initialStateIdle = {
-        data: undefined,
-        error: null,
-        status: 'idle'
-    };
-    const initialStateConnecting = {
-        data: undefined,
-        error: null,
-        status: 'connecting'
-    };
-    /* istanbul ignore next -- @preserve */ function useSubscription(path, input, opts) {
-        const enabled = opts?.enabled ?? input !== reactQuery.skipToken;
-        const queryKey = reactQuery.hashKey(getQueryKey.getQueryKeyInternal(path, input, 'any'));
-        const { client } = useContext();
-        const optsRef = React__namespace.useRef(opts);
-        React__namespace.useEffect(()=>{
-            optsRef.current = opts;
-        });
-        const [trackedProps] = React__namespace.useState(new Set([]));
-        const addTrackedProp = React__namespace.useCallback((key)=>{
-            trackedProps.add(key);
-        }, [
-            trackedProps
-        ]);
-        const currentSubscriptionRef = React__namespace.useRef(null);
-        const updateState = React__namespace.useCallback((callback)=>{
-            const prev = resultRef.current;
-            const next = resultRef.current = callback(prev);
-            let shouldUpdate = false;
-            for (const key of trackedProps){
-                if (prev[key] !== next[key]) {
-                    shouldUpdate = true;
-                    break;
-                }
-            }
-            if (shouldUpdate) {
-                setState(trackResult(next, addTrackedProp));
-            }
-        }, [
-            addTrackedProp,
-            trackedProps
-        ]);
-        const reset = React__namespace.useCallback(()=>{
-            // unsubscribe from the previous subscription
-            currentSubscriptionRef.current?.unsubscribe();
-            if (!enabled) {
-                updateState(()=>({
-                        ...initialStateIdle,
-                        reset
-                    }));
-                return;
-            }
-            updateState(()=>({
-                    ...initialStateConnecting,
-                    reset
-                }));
-            const subscription = client.subscription(path.join('.'), input ?? undefined, {
-                onStarted: ()=>{
-                    optsRef.current.onStarted?.();
-                    updateState((prev)=>({
-                            ...prev,
-                            status: 'pending',
-                            error: null
-                        }));
-                },
-                onData: (data)=>{
-                    optsRef.current.onData?.(data);
-                    updateState((prev)=>({
-                            ...prev,
-                            status: 'pending',
-                            data,
-                            error: null
-                        }));
-                },
-                onError: (error)=>{
-                    optsRef.current.onError?.(error);
-                    updateState((prev)=>({
-                            ...prev,
-                            status: 'error',
-                            error
-                        }));
-                },
-                onConnectionStateChange: (result)=>{
-                    updateState((prev)=>{
-                        switch(result.state){
-                            case 'idle':
-                                return {
-                                    ...prev,
-                                    status: result.state,
-                                    error: null,
-                                    data: undefined
-                                };
-                            case 'connecting':
-                                return {
-                                    ...prev,
-                                    error: result.error,
-                                    status: result.state
-                                };
-                            case 'pending':
-                                // handled when data is / onStarted
-                                return prev;
-                        }
-                    });
-                },
-                onComplete: ()=>{
-                    optsRef.current.onComplete?.();
-                    // In the case of WebSockets, the connection might not be idle so `onConnectionStateChange` will not be called until the connection is closed.
-                    // In this case, we need to set the state to idle manually.
-                    updateState((prev)=>({
-                            ...prev,
-                            status: 'idle',
-                            error: null,
-                            data: undefined
-                        }));
-                // (We might want to add a `connectionState` to the state to track the connection state separately)
-                }
-            });
-            currentSubscriptionRef.current = subscription;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        }, [
-            client,
-            queryKey,
-            enabled,
-            updateState
-        ]);
-        React__namespace.useEffect(()=>{
-            reset();
-            return ()=>{
-                currentSubscriptionRef.current?.unsubscribe();
-            };
-        }, [
-            reset
-        ]);
-        const resultRef = React__namespace.useRef(enabled ? {
-            ...initialStateConnecting,
-            reset
-        } : {
-            ...initialStateIdle,
-            reset
-        });
-        const [state, setState] = React__namespace.useState(trackResult(resultRef.current, addTrackedProp));
-        return state;
-    }
-    function useInfiniteQuery(path, input, opts) {
-        const { client, ssrState, prefetchInfiniteQuery, queryClient, abortOnUnmount } = useContext();
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'infinite');
-        const defaultOpts = queryClient.getQueryDefaults(queryKey);
-        const isInputSkipToken = input === reactQuery.skipToken;
-        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !isInputSkipToken && !queryClient.getQueryCache().find({
-            queryKey
-        })) {
-            void prefetchInfiniteQuery(queryKey, {
-                ...defaultOpts,
-                ...opts
-            });
-        }
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts
-        });
-        // request option should take priority over global
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
-        const hook = reactQuery.useInfiniteQuery({
-            ...ssrOpts,
-            initialPageParam: opts.initialCursor ?? null,
-            persister: opts.persister,
-            queryKey: queryKey,
-            queryFn: isInputSkipToken ? input : (queryFunctionContext)=>{
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {
-                            signal: null
-                        }
-                    }
-                };
-                return client.query(...getClientArgs.getClientArgs(queryKey, actualOpts, {
-                    pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
-                    direction: queryFunctionContext.direction
-                }));
-            }
-        }, queryClient);
-        hook.trpc = trpcResult.useHookResult({
-            path
-        });
-        return hook;
-    }
-    function usePrefetchInfiniteQuery(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'infinite');
-        const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
-        const isInputSkipToken = input === reactQuery.skipToken;
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts
-        });
-        // request option should take priority over global
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
-        reactQuery.usePrefetchInfiniteQuery({
-            ...opts,
-            initialPageParam: opts.initialCursor ?? null,
-            queryKey,
-            queryFn: isInputSkipToken ? input : (queryFunctionContext)=>{
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {}
-                    }
-                };
-                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts, {
-                    pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
-                    direction: queryFunctionContext.direction
-                }));
-            }
-        });
-    }
-    function useSuspenseInfiniteQuery(path, input, opts) {
-        const context = useContext();
-        const queryKey = getQueryKey.getQueryKeyInternal(path, input, 'infinite');
-        const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
-        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
-            ...defaultOpts,
-            ...opts
-        });
-        // request option should take priority over global
-        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
-        const hook = reactQuery.useSuspenseInfiniteQuery({
-            ...opts,
-            initialPageParam: opts.initialCursor ?? null,
-            queryKey,
-            queryFn: (queryFunctionContext)=>{
-                const actualOpts = {
-                    ...ssrOpts,
-                    trpc: {
-                        ...ssrOpts?.trpc,
-                        ...shouldAbortOnUnmount ? {
-                            signal: queryFunctionContext.signal
-                        } : {}
-                    }
-                };
-                return context.client.query(...getClientArgs.getClientArgs(queryKey, actualOpts, {
-                    pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
-                    direction: queryFunctionContext.direction
-                }));
-            }
-        }, context.queryClient);
-        hook.trpc = trpcResult.useHookResult({
-            path
-        });
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return [
-            hook.data,
-            hook
-        ];
-    }
-    const useQueries = (queriesCallback, options)=>{
-        const { ssrState, queryClient, prefetchQuery, client } = useContext();
-        const proxy = useQueriesProxy.createUseQueries(client);
-        const queries = queriesCallback(proxy);
-        if (typeof window === 'undefined' && ssrState === 'prepass') {
-            for (const query of queries){
-                const queryOption = query;
-                if (queryOption.trpc?.ssr !== false && !queryClient.getQueryCache().find({
-                    queryKey: queryOption.queryKey
-                })) {
-                    void prefetchQuery(queryOption.queryKey, queryOption);
-                }
-            }
-        }
-        return reactQuery.useQueries({
-            queries: queries.map((query)=>({
-                    ...query,
-                    queryKey: query.queryKey
-                })),
-            combine: options?.combine
-        }, queryClient);
-    };
-    const useSuspenseQueries = (queriesCallback)=>{
-        const { queryClient, client } = useContext();
-        const proxy = useQueriesProxy.createUseQueries(client);
-        const queries = queriesCallback(proxy);
-        const hook = reactQuery.useSuspenseQueries({
-            queries: queries.map((query)=>({
-                    ...query,
-                    queryFn: query.queryFn,
-                    queryKey: query.queryKey
-                }))
-        }, queryClient);
-        return [
-            hook.map((h)=>h.data),
-            hook
-        ];
-    };
-    return {
-        Provider: TRPCProvider,
-        createClient,
-        useContext,
-        useUtils: useContext,
-        useQuery,
-        usePrefetchQuery,
-        useSuspenseQuery,
-        useQueries,
-        useSuspenseQueries,
-        useMutation,
-        useSubscription,
-        useInfiniteQuery,
-        usePrefetchInfiniteQuery,
-        useSuspenseInfiniteQuery
-    };
+* @internal
+*/
+function createRootHooks(config) {
+	const mutationSuccessOverride = config?.overrides?.useMutation?.onSuccess ?? ((options) => options.originalFn());
+	const Context = config?.context ?? require__Users_julius_dev_trpc_packages_react_query_src_internals_context.TRPCContext;
+	const createClient = __trpc_client.createTRPCClient;
+	const TRPCProvider = (props) => {
+		const { abortOnUnmount = false, queryClient, ssrContext } = props;
+		const [ssrState, setSSRState] = react.useState(props.ssrState ?? false);
+		const client = props.client instanceof __trpc_client.TRPCUntypedClient ? props.client : (0, __trpc_client.getUntypedClient)(props.client);
+		const fns = react.useMemo(() => require__Users_julius_dev_trpc_packages_react_query_src_utils_createUtilityFunctions.createUtilityFunctions({
+			client,
+			queryClient
+		}), [client, queryClient]);
+		const contextValue = react.useMemo(() => ({
+			abortOnUnmount,
+			queryClient,
+			client,
+			ssrContext: ssrContext ?? null,
+			ssrState,
+			...fns
+		}), [
+			abortOnUnmount,
+			client,
+			fns,
+			queryClient,
+			ssrContext,
+			ssrState
+		]);
+		react.useEffect(() => {
+			setSSRState((state) => state ? "mounted" : false);
+		}, []);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Context.Provider, {
+			value: contextValue,
+			children: props.children
+		});
+	};
+	function useContext() {
+		const context = react.useContext(Context);
+		if (!context) throw new Error("Unable to find tRPC Context. Did you forget to wrap your App inside `withTRPC` HoC?");
+		return context;
+	}
+	/**
+	* Hack to make sure errors return `status`='error` when doing SSR
+	* @see https://github.com/trpc/trpc/pull/1645
+	*/
+	function useSSRQueryOptionsIfNeeded(queryKey, opts) {
+		const { queryClient, ssrState } = useContext();
+		return ssrState && ssrState !== "mounted" && queryClient.getQueryCache().find({ queryKey })?.state.status === "error" ? {
+			retryOnMount: false,
+			...opts
+		} : opts;
+	}
+	function useQuery(path, input, opts) {
+		const context = useContext();
+		const { abortOnUnmount, client, ssrState, queryClient, prefetchQuery } = context;
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "query");
+		const defaultOpts = queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === __tanstack_react_query.skipToken;
+		if (typeof window === "undefined" && ssrState === "prepass" && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !isInputSkipToken && !queryClient.getQueryCache().find({ queryKey })) prefetchQuery(queryKey, opts);
+		const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? abortOnUnmount;
+		const hook = (0, __tanstack_react_query.useQuery)({
+			...ssrOpts,
+			queryKey,
+			queryFn: isInputSkipToken ? input : async (queryFunctionContext) => {
+				const actualOpts = {
+					...ssrOpts,
+					trpc: {
+						...ssrOpts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : { signal: null }
+					}
+				};
+				const result = await client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts));
+				if ((0, __trpc_server_unstable_core_do_not_import.isAsyncIterable)(result)) return require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.buildQueryFromAsyncIterable(result, queryClient, queryKey);
+				return result;
+			}
+		}, queryClient);
+		hook.trpc = require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.useHookResult({ path });
+		return hook;
+	}
+	function usePrefetchQuery(path, input, opts) {
+		const context = useContext();
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "query");
+		const isInputSkipToken = input === __tanstack_react_query.skipToken;
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
+		(0, __tanstack_react_query.usePrefetchQuery)({
+			...opts,
+			queryKey,
+			queryFn: isInputSkipToken ? input : (queryFunctionContext) => {
+				const actualOpts = { trpc: {
+					...opts?.trpc,
+					...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : {}
+				} };
+				return context.client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts));
+			}
+		});
+	}
+	function useSuspenseQuery(path, input, opts) {
+		const context = useContext();
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "query");
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
+		const hook = (0, __tanstack_react_query.useSuspenseQuery)({
+			...opts,
+			queryKey,
+			queryFn: (queryFunctionContext) => {
+				const actualOpts = {
+					...opts,
+					trpc: {
+						...opts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : { signal: null }
+					}
+				};
+				return context.client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts));
+			}
+		}, context.queryClient);
+		hook.trpc = require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.useHookResult({ path });
+		return [hook.data, hook];
+	}
+	function useMutation(path, opts) {
+		const { client, queryClient } = useContext();
+		const mutationKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getMutationKeyInternal(path);
+		const defaultOpts = queryClient.defaultMutationOptions(queryClient.getMutationDefaults(mutationKey));
+		const hook = (0, __tanstack_react_query.useMutation)({
+			...opts,
+			mutationKey,
+			mutationFn: (input) => {
+				return client.mutation(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs([path, { input }], opts));
+			},
+			onSuccess(...args) {
+				const originalFn = () => opts?.onSuccess?.(...args) ?? defaultOpts?.onSuccess?.(...args);
+				return mutationSuccessOverride({
+					originalFn,
+					queryClient,
+					meta: opts?.meta ?? defaultOpts?.meta ?? {}
+				});
+			}
+		}, queryClient);
+		hook.trpc = require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.useHookResult({ path });
+		return hook;
+	}
+	const initialStateIdle = {
+		data: void 0,
+		error: null,
+		status: "idle"
+	};
+	const initialStateConnecting = {
+		data: void 0,
+		error: null,
+		status: "connecting"
+	};
+	/* istanbul ignore next -- @preserve */
+	function useSubscription(path, input, opts) {
+		const enabled = opts?.enabled ?? input !== __tanstack_react_query.skipToken;
+		const queryKey = (0, __tanstack_react_query.hashKey)(require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "any"));
+		const { client } = useContext();
+		const optsRef = react.useRef(opts);
+		react.useEffect(() => {
+			optsRef.current = opts;
+		});
+		const [trackedProps] = react.useState(new Set([]));
+		const addTrackedProp = react.useCallback((key) => {
+			trackedProps.add(key);
+		}, [trackedProps]);
+		const currentSubscriptionRef = react.useRef(null);
+		const updateState = react.useCallback((callback) => {
+			const prev = resultRef.current;
+			const next = resultRef.current = callback(prev);
+			let shouldUpdate = false;
+			for (const key of trackedProps) if (prev[key] !== next[key]) {
+				shouldUpdate = true;
+				break;
+			}
+			if (shouldUpdate) setState(trackResult(next, addTrackedProp));
+		}, [addTrackedProp, trackedProps]);
+		const reset = react.useCallback(() => {
+			currentSubscriptionRef.current?.unsubscribe();
+			if (!enabled) {
+				updateState(() => ({
+					...initialStateIdle,
+					reset
+				}));
+				return;
+			}
+			updateState(() => ({
+				...initialStateConnecting,
+				reset
+			}));
+			const subscription = client.subscription(path.join("."), input ?? void 0, {
+				onStarted: () => {
+					optsRef.current.onStarted?.();
+					updateState((prev) => ({
+						...prev,
+						status: "pending",
+						error: null
+					}));
+				},
+				onData: (data) => {
+					optsRef.current.onData?.(data);
+					updateState((prev) => ({
+						...prev,
+						status: "pending",
+						data,
+						error: null
+					}));
+				},
+				onError: (error) => {
+					optsRef.current.onError?.(error);
+					updateState((prev) => ({
+						...prev,
+						status: "error",
+						error
+					}));
+				},
+				onConnectionStateChange: (result) => {
+					updateState((prev) => {
+						switch (result.state) {
+							case "idle": return {
+								...prev,
+								status: result.state,
+								error: null,
+								data: void 0
+							};
+							case "connecting": return {
+								...prev,
+								error: result.error,
+								status: result.state
+							};
+							case "pending": return prev;
+						}
+					});
+				},
+				onComplete: () => {
+					optsRef.current.onComplete?.();
+					updateState((prev) => ({
+						...prev,
+						status: "idle",
+						error: null,
+						data: void 0
+					}));
+				}
+			});
+			currentSubscriptionRef.current = subscription;
+		}, [
+			client,
+			queryKey,
+			enabled,
+			updateState
+		]);
+		react.useEffect(() => {
+			reset();
+			return () => {
+				currentSubscriptionRef.current?.unsubscribe();
+			};
+		}, [reset]);
+		const resultRef = react.useRef(enabled ? {
+			...initialStateConnecting,
+			reset
+		} : {
+			...initialStateIdle,
+			reset
+		});
+		const [state, setState] = react.useState(trackResult(resultRef.current, addTrackedProp));
+		return state;
+	}
+	function useInfiniteQuery(path, input, opts) {
+		const { client, ssrState, prefetchInfiniteQuery, queryClient, abortOnUnmount } = useContext();
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "infinite");
+		const defaultOpts = queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === __tanstack_react_query.skipToken;
+		if (typeof window === "undefined" && ssrState === "prepass" && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !isInputSkipToken && !queryClient.getQueryCache().find({ queryKey })) prefetchInfiniteQuery(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
+		const hook = (0, __tanstack_react_query.useInfiniteQuery)({
+			...ssrOpts,
+			initialPageParam: opts.initialCursor ?? null,
+			persister: opts.persister,
+			queryKey,
+			queryFn: isInputSkipToken ? input : (queryFunctionContext) => {
+				const actualOpts = {
+					...ssrOpts,
+					trpc: {
+						...ssrOpts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : { signal: null }
+					}
+				};
+				return client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		}, queryClient);
+		hook.trpc = require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.useHookResult({ path });
+		return hook;
+	}
+	function usePrefetchInfiniteQuery(path, input, opts) {
+		const context = useContext();
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "infinite");
+		const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === __tanstack_react_query.skipToken;
+		const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
+		(0, __tanstack_react_query.usePrefetchInfiniteQuery)({
+			...opts,
+			initialPageParam: opts.initialCursor ?? null,
+			queryKey,
+			queryFn: isInputSkipToken ? input : (queryFunctionContext) => {
+				const actualOpts = {
+					...ssrOpts,
+					trpc: {
+						...ssrOpts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : {}
+					}
+				};
+				return context.client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		});
+	}
+	function useSuspenseInfiniteQuery(path, input, opts) {
+		const context = useContext();
+		const queryKey = require__Users_julius_dev_trpc_packages_react_query_src_internals_getQueryKey.getQueryKeyInternal(path, input, "infinite");
+		const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
+		const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
+		const hook = (0, __tanstack_react_query.useSuspenseInfiniteQuery)({
+			...opts,
+			initialPageParam: opts.initialCursor ?? null,
+			queryKey,
+			queryFn: (queryFunctionContext) => {
+				const actualOpts = {
+					...ssrOpts,
+					trpc: {
+						...ssrOpts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : {}
+					}
+				};
+				return context.client.query(...require__Users_julius_dev_trpc_packages_react_query_src_internals_getClientArgs.getClientArgs(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		}, context.queryClient);
+		hook.trpc = require__Users_julius_dev_trpc_packages_react_query_src_internals_trpcResult.useHookResult({ path });
+		return [hook.data, hook];
+	}
+	const useQueries = (queriesCallback, options) => {
+		const { ssrState, queryClient, prefetchQuery, client } = useContext();
+		const proxy = require__Users_julius_dev_trpc_packages_react_query_src_shared_proxy_useQueriesProxy.createUseQueries(client);
+		const queries = queriesCallback(proxy);
+		if (typeof window === "undefined" && ssrState === "prepass") for (const query of queries) {
+			const queryOption = query;
+			if (queryOption.trpc?.ssr !== false && !queryClient.getQueryCache().find({ queryKey: queryOption.queryKey })) prefetchQuery(queryOption.queryKey, queryOption);
+		}
+		return (0, __tanstack_react_query.useQueries)({
+			queries: queries.map((query) => ({
+				...query,
+				queryKey: query.queryKey
+			})),
+			combine: options?.combine
+		}, queryClient);
+	};
+	const useSuspenseQueries = (queriesCallback) => {
+		const { queryClient, client } = useContext();
+		const proxy = require__Users_julius_dev_trpc_packages_react_query_src_shared_proxy_useQueriesProxy.createUseQueries(client);
+		const queries = queriesCallback(proxy);
+		const hook = (0, __tanstack_react_query.useSuspenseQueries)({ queries: queries.map((query) => ({
+			...query,
+			queryFn: query.queryFn,
+			queryKey: query.queryKey
+		})) }, queryClient);
+		return [hook.map((h) => h.data), hook];
+	};
+	return {
+		Provider: TRPCProvider,
+		createClient,
+		useContext,
+		useUtils: useContext,
+		useQuery,
+		usePrefetchQuery,
+		useSuspenseQuery,
+		useQueries,
+		useSuspenseQueries,
+		useMutation,
+		useSubscription,
+		useInfiniteQuery,
+		usePrefetchInfiniteQuery,
+		useSuspenseInfiniteQuery
+	};
 }
 
-exports.createRootHooks = createRootHooks;
+//#endregion
+exports.createRootHooks = createRootHooks;