@trpc/react-query 11.3.1 → 11.3.2-canary.2

package/dist/shared-CMPBsqju.mjs

@@ -0,0 +1,784 @@
+import { getMutationKeyInternal, getQueryKeyInternal } from "./getQueryKey-Dekty44G.mjs";
+import { TRPCUntypedClient, createTRPCClient, createTRPCClientProxy, getUntypedClient } from "@trpc/client";
+import { QueryClient, hashKey, infiniteQueryOptions, queryOptions, skipToken, useInfiniteQuery, useMutation, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery } from "@tanstack/react-query";
+import { createFlatProxy, createRecursiveProxy, isAsyncIterable } from "@trpc/server/unstable-core-do-not-import";
+import * as React$2 from "react";
+import * as React$1 from "react";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/shared/proxy/decorationProxy.ts
+/**
+* Create proxy for decorating procedures
+* @internal
+*/
+function createReactDecoration(hooks) {
+	return createRecursiveProxy(({ path, args }) => {
+		const pathCopy = [...path];
+		const lastArg = pathCopy.pop();
+		if (lastArg === "useMutation") return hooks[lastArg](pathCopy, ...args);
+		if (lastArg === "_def") return { path: pathCopy };
+		const [input, ...rest] = args;
+		const opts = rest[0] ?? {};
+		return hooks[lastArg](pathCopy, input, opts);
+	});
+}
+
+//#endregion
+//#region src/internals/context.tsx
+const contextProps = [
+	"client",
+	"ssrContext",
+	"ssrState",
+	"abortOnUnmount"
+];
+const TRPCContext = React$2.createContext?.(null);
+
+//#endregion
+//#region src/shared/proxy/utilsProxy.ts
+const getQueryType = (utilName) => {
+	switch (utilName) {
+		case "queryOptions":
+		case "fetch":
+		case "ensureData":
+		case "prefetch":
+		case "getData":
+		case "setData":
+		case "setQueriesData": return "query";
+		case "infiniteQueryOptions":
+		case "fetchInfinite":
+		case "prefetchInfinite":
+		case "getInfiniteData":
+		case "setInfiniteData": return "infinite";
+		case "setMutationDefaults":
+		case "getMutationDefaults":
+		case "isMutating":
+		case "cancel":
+		case "invalidate":
+		case "refetch":
+		case "reset": return "any";
+	}
+};
+/**
+* @internal
+*/
+function createRecursiveUtilsProxy(context) {
+	return createRecursiveProxy((opts) => {
+		const path = [...opts.path];
+		const utilName = path.pop();
+		const args = [...opts.args];
+		const input = args.shift();
+		const queryType = getQueryType(utilName);
+		const queryKey = getQueryKeyInternal(path, input, queryType);
+		const contextMap = {
+			infiniteQueryOptions: () => context.infiniteQueryOptions(path, queryKey, args[0]),
+			queryOptions: () => context.queryOptions(path, queryKey, ...args),
+			fetch: () => context.fetchQuery(queryKey, ...args),
+			fetchInfinite: () => context.fetchInfiniteQuery(queryKey, args[0]),
+			prefetch: () => context.prefetchQuery(queryKey, ...args),
+			prefetchInfinite: () => context.prefetchInfiniteQuery(queryKey, args[0]),
+			ensureData: () => context.ensureQueryData(queryKey, ...args),
+			invalidate: () => context.invalidateQueries(queryKey, ...args),
+			reset: () => context.resetQueries(queryKey, ...args),
+			refetch: () => context.refetchQueries(queryKey, ...args),
+			cancel: () => context.cancelQuery(queryKey, ...args),
+			setData: () => {
+				context.setQueryData(queryKey, args[0], args[1]);
+			},
+			setQueriesData: () => context.setQueriesData(queryKey, args[0], args[1], args[2]),
+			setInfiniteData: () => {
+				context.setInfiniteQueryData(queryKey, args[0], args[1]);
+			},
+			getData: () => context.getQueryData(queryKey),
+			getInfiniteData: () => context.getInfiniteQueryData(queryKey),
+			setMutationDefaults: () => context.setMutationDefaults(getMutationKeyInternal(path), input),
+			getMutationDefaults: () => context.getMutationDefaults(getMutationKeyInternal(path)),
+			isMutating: () => context.isMutating({ mutationKey: getMutationKeyInternal(path) })
+		};
+		return contextMap[utilName]();
+	});
+}
+/**
+* @internal
+*/
+function createReactQueryUtils(context) {
+	const clientProxy = createTRPCClientProxy(context.client);
+	const proxy = createRecursiveUtilsProxy(context);
+	return createFlatProxy((key) => {
+		const contextName = key;
+		if (contextName === "client") return clientProxy;
+		if (contextProps.includes(contextName)) return context[contextName];
+		return proxy[key];
+	});
+}
+/**
+* @internal
+*/
+function createQueryUtilsProxy(context) {
+	return createRecursiveUtilsProxy(context);
+}
+
+//#endregion
+//#region src/shared/proxy/useQueriesProxy.ts
+/**
+* Create proxy for `useQueries` options
+* @internal
+*/
+function createUseQueries(client) {
+	const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+	return createRecursiveProxy((opts) => {
+		const arrayPath = opts.path;
+		const dotPath = arrayPath.join(".");
+		const [input, _opts] = opts.args;
+		const options = {
+			queryKey: getQueryKeyInternal(arrayPath, input, "query"),
+			queryFn: () => {
+				return untypedClient.query(dotPath, input, _opts?.trpc);
+			},
+			..._opts
+		};
+		return options;
+	});
+}
+
+//#endregion
+//#region src/internals/getClientArgs.ts
+/**
+* @internal
+*/
+function getClientArgs(queryKey, opts, infiniteParams) {
+	const path = queryKey[0];
+	let input = queryKey[1]?.input;
+	if (infiniteParams) input = {
+		...input ?? {},
+		...infiniteParams.pageParam ? { cursor: infiniteParams.pageParam } : {},
+		direction: infiniteParams.direction
+	};
+	return [
+		path.join("."),
+		input,
+		opts?.trpc
+	];
+}
+
+//#endregion
+//#region src/internals/trpcResult.ts
+function createTRPCOptionsResult(value) {
+	const path = value.path.join(".");
+	return { path };
+}
+/**
+* Makes a stable reference of the `trpc` prop
+*/
+function useHookResult(value) {
+	const result = createTRPCOptionsResult(value);
+	return React$1.useMemo(() => result, [result]);
+}
+/**
+* @internal
+*/
+async function buildQueryFromAsyncIterable(asyncIterable, queryClient, queryKey) {
+	const queryCache = queryClient.getQueryCache();
+	const query = queryCache.build(queryClient, { queryKey });
+	query.setState({
+		data: [],
+		status: "success"
+	});
+	const aggregate = [];
+	for await (const value of asyncIterable) {
+		aggregate.push(value);
+		query.setState({ data: [...aggregate] });
+	}
+	return aggregate;
+}
+
+//#endregion
+//#region src/utils/createUtilityFunctions.ts
+/**
+* Creates a set of utility functions that can be used to interact with `react-query`
+* @param opts the `TRPCClient` and `QueryClient` to use
+* @returns a set of utility functions that can be used to interact with `react-query`
+* @internal
+*/
+function createUtilityFunctions(opts) {
+	const { client, queryClient } = opts;
+	const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+	return {
+		infiniteQueryOptions: (path, queryKey, opts$1) => {
+			const inputIsSkipToken = queryKey[1]?.input === skipToken;
+			const queryFn = async (queryFnContext) => {
+				const actualOpts = {
+					...opts$1,
+					trpc: {
+						...opts$1?.trpc,
+						...opts$1?.trpc?.abortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
+					}
+				};
+				const result = await untypedClient.query(...getClientArgs(queryKey, actualOpts, {
+					direction: queryFnContext.direction,
+					pageParam: queryFnContext.pageParam
+				}));
+				return result;
+			};
+			return Object.assign(infiniteQueryOptions({
+				...opts$1,
+				initialData: opts$1?.initialData,
+				queryKey,
+				queryFn: inputIsSkipToken ? skipToken : queryFn,
+				initialPageParam: opts$1?.initialCursor ?? null
+			}), { trpc: createTRPCOptionsResult({ path }) });
+		},
+		queryOptions: (path, queryKey, opts$1) => {
+			const inputIsSkipToken = queryKey[1]?.input === skipToken;
+			const queryFn = async (queryFnContext) => {
+				const actualOpts = {
+					...opts$1,
+					trpc: {
+						...opts$1?.trpc,
+						...opts$1?.trpc?.abortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
+					}
+				};
+				const result = await untypedClient.query(...getClientArgs(queryKey, actualOpts));
+				if (isAsyncIterable(result)) return buildQueryFromAsyncIterable(result, queryClient, queryKey);
+				return result;
+			};
+			return Object.assign(queryOptions({
+				...opts$1,
+				initialData: opts$1?.initialData,
+				queryKey,
+				queryFn: inputIsSkipToken ? skipToken : queryFn
+			}), { trpc: createTRPCOptionsResult({ path }) });
+		},
+		fetchQuery: (queryKey, opts$1) => {
+			return queryClient.fetchQuery({
+				...opts$1,
+				queryKey,
+				queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts$1))
+			});
+		},
+		fetchInfiniteQuery: (queryKey, opts$1) => {
+			return queryClient.fetchInfiniteQuery({
+				...opts$1,
+				queryKey,
+				queryFn: ({ pageParam, direction }) => {
+					return untypedClient.query(...getClientArgs(queryKey, opts$1, {
+						pageParam,
+						direction
+					}));
+				},
+				initialPageParam: opts$1?.initialCursor ?? null
+			});
+		},
+		prefetchQuery: (queryKey, opts$1) => {
+			return queryClient.prefetchQuery({
+				...opts$1,
+				queryKey,
+				queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts$1))
+			});
+		},
+		prefetchInfiniteQuery: (queryKey, opts$1) => {
+			return queryClient.prefetchInfiniteQuery({
+				...opts$1,
+				queryKey,
+				queryFn: ({ pageParam, direction }) => {
+					return untypedClient.query(...getClientArgs(queryKey, opts$1, {
+						pageParam,
+						direction
+					}));
+				},
+				initialPageParam: opts$1?.initialCursor ?? null
+			});
+		},
+		ensureQueryData: (queryKey, opts$1) => {
+			return queryClient.ensureQueryData({
+				...opts$1,
+				queryKey,
+				queryFn: () => untypedClient.query(...getClientArgs(queryKey, opts$1))
+			});
+		},
+		invalidateQueries: (queryKey, filters, options) => {
+			return queryClient.invalidateQueries({
+				...filters,
+				queryKey
+			}, options);
+		},
+		resetQueries: (queryKey, filters, options) => {
+			return queryClient.resetQueries({
+				...filters,
+				queryKey
+			}, options);
+		},
+		refetchQueries: (queryKey, filters, options) => {
+			return queryClient.refetchQueries({
+				...filters,
+				queryKey
+			}, options);
+		},
+		cancelQuery: (queryKey, options) => {
+			return queryClient.cancelQueries({ queryKey }, options);
+		},
+		setQueryData: (queryKey, updater, options) => {
+			return queryClient.setQueryData(queryKey, updater, options);
+		},
+		setQueriesData: (queryKey, filters, updater, options) => {
+			return queryClient.setQueriesData({
+				...filters,
+				queryKey
+			}, updater, options);
+		},
+		getQueryData: (queryKey) => {
+			return queryClient.getQueryData(queryKey);
+		},
+		setInfiniteQueryData: (queryKey, updater, options) => {
+			return queryClient.setQueryData(queryKey, updater, options);
+		},
+		getInfiniteQueryData: (queryKey) => {
+			return queryClient.getQueryData(queryKey);
+		},
+		setMutationDefaults: (mutationKey, options) => {
+			const path = mutationKey[0];
+			const canonicalMutationFn = (input) => {
+				return untypedClient.mutation(...getClientArgs([path, { input }], opts));
+			};
+			return queryClient.setMutationDefaults(mutationKey, typeof options === "function" ? options({ canonicalMutationFn }) : options);
+		},
+		getMutationDefaults: (mutationKey) => {
+			return queryClient.getMutationDefaults(mutationKey);
+		},
+		isMutating: (filters) => {
+			return queryClient.isMutating({
+				...filters,
+				exact: true
+			});
+		}
+	};
+}
+
+//#endregion
+//#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 ?? TRPCContext;
+	const createClient = createTRPCClient;
+	const TRPCProvider = (props) => {
+		const { abortOnUnmount = false, queryClient, ssrContext } = props;
+		const [ssrState, setSSRState] = React.useState(props.ssrState ?? false);
+		const client = props.client instanceof TRPCUntypedClient ? props.client : getUntypedClient(props.client);
+		const fns = React.useMemo(() => 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__ */ 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$1(path, input, opts) {
+		const context = useContext();
+		const { abortOnUnmount, client, ssrState, queryClient, prefetchQuery } = context;
+		const queryKey = getQueryKeyInternal(path, input, "query");
+		const defaultOpts = queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === 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 = 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(...getClientArgs(queryKey, actualOpts));
+				if (isAsyncIterable(result)) return buildQueryFromAsyncIterable(result, queryClient, queryKey);
+				return result;
+			}
+		}, queryClient);
+		hook.trpc = useHookResult({ path });
+		return hook;
+	}
+	function usePrefetchQuery$1(path, input, opts) {
+		const context = useContext();
+		const queryKey = getQueryKeyInternal(path, input, "query");
+		const isInputSkipToken = input === skipToken;
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
+		usePrefetchQuery({
+			...opts,
+			queryKey,
+			queryFn: isInputSkipToken ? input : (queryFunctionContext) => {
+				const actualOpts = { trpc: {
+					...opts?.trpc,
+					...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : {}
+				} };
+				return context.client.query(...getClientArgs(queryKey, actualOpts));
+			}
+		});
+	}
+	function useSuspenseQuery$1(path, input, opts) {
+		const context = useContext();
+		const queryKey = getQueryKeyInternal(path, input, "query");
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
+		const hook = useSuspenseQuery({
+			...opts,
+			queryKey,
+			queryFn: (queryFunctionContext) => {
+				const actualOpts = {
+					...opts,
+					trpc: {
+						...opts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : { signal: null }
+					}
+				};
+				return context.client.query(...getClientArgs(queryKey, actualOpts));
+			}
+		}, context.queryClient);
+		hook.trpc = useHookResult({ path });
+		return [hook.data, hook];
+	}
+	function useMutation$1(path, opts) {
+		const { client, queryClient } = useContext();
+		const mutationKey = getMutationKeyInternal(path);
+		const defaultOpts = queryClient.defaultMutationOptions(queryClient.getMutationDefaults(mutationKey));
+		const hook = useMutation({
+			...opts,
+			mutationKey,
+			mutationFn: (input) => {
+				return client.mutation(...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 = 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 !== skipToken;
+		const queryKey = hashKey(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$1(path, input, opts) {
+		const { client, ssrState, prefetchInfiniteQuery, queryClient, abortOnUnmount } = useContext();
+		const queryKey = getQueryKeyInternal(path, input, "infinite");
+		const defaultOpts = queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === 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 = 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(...getClientArgs(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		}, queryClient);
+		hook.trpc = useHookResult({ path });
+		return hook;
+	}
+	function usePrefetchInfiniteQuery$1(path, input, opts) {
+		const context = useContext();
+		const queryKey = getQueryKeyInternal(path, input, "infinite");
+		const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
+		const isInputSkipToken = input === skipToken;
+		const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+			...defaultOpts,
+			...opts
+		});
+		const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
+		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(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		});
+	}
+	function useSuspenseInfiniteQuery$1(path, input, opts) {
+		const context = useContext();
+		const queryKey = 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 = useSuspenseInfiniteQuery({
+			...opts,
+			initialPageParam: opts.initialCursor ?? null,
+			queryKey,
+			queryFn: (queryFunctionContext) => {
+				const actualOpts = {
+					...ssrOpts,
+					trpc: {
+						...ssrOpts?.trpc,
+						...shouldAbortOnUnmount ? { signal: queryFunctionContext.signal } : {}
+					}
+				};
+				return context.client.query(...getClientArgs(queryKey, actualOpts, {
+					pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+					direction: queryFunctionContext.direction
+				}));
+			}
+		}, context.queryClient);
+		hook.trpc = useHookResult({ path });
+		return [hook.data, hook];
+	}
+	const useQueries$1 = (queriesCallback, options) => {
+		const { ssrState, queryClient, prefetchQuery, client } = useContext();
+		const proxy = 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 useQueries({
+			queries: queries.map((query) => ({
+				...query,
+				queryKey: query.queryKey
+			})),
+			combine: options?.combine
+		}, queryClient);
+	};
+	const useSuspenseQueries$1 = (queriesCallback) => {
+		const { queryClient, client } = useContext();
+		const proxy = createUseQueries(client);
+		const queries = queriesCallback(proxy);
+		const hook = 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: useQuery$1,
+		usePrefetchQuery: usePrefetchQuery$1,
+		useSuspenseQuery: useSuspenseQuery$1,
+		useQueries: useQueries$1,
+		useSuspenseQueries: useSuspenseQueries$1,
+		useMutation: useMutation$1,
+		useSubscription,
+		useInfiniteQuery: useInfiniteQuery$1,
+		usePrefetchInfiniteQuery: usePrefetchInfiniteQuery$1,
+		useSuspenseInfiniteQuery: useSuspenseInfiniteQuery$1
+	};
+}
+
+//#endregion
+//#region src/shared/queryClient.ts
+/**
+* @internal
+*/
+const getQueryClient = (config) => config.queryClient ?? new QueryClient(config.queryClientConfig);
+
+//#endregion
+export { TRPCContext, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, createUtilityFunctions, getClientArgs, getQueryClient, getQueryType };
+//# sourceMappingURL=shared-CMPBsqju.mjs.map