@trpc/tanstack-react-query 11.3.1 → 11.3.2-canary.4

package/dist/index.cjs

@@ -0,0 +1,465 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const react = __toESM(require("react"));
+const __trpc_client = __toESM(require("@trpc/client"));
+const __trpc_server = __toESM(require("@trpc/server"));
+const __tanstack_react_query = __toESM(require("@tanstack/react-query"));
+const __trpc_server_unstable_core_do_not_import = __toESM(require("@trpc/server/unstable-core-do-not-import"));
+const react_jsx_runtime = __toESM(require("react/jsx-runtime"));
+
+//#region src/internals/utils.ts
+/**
+* @internal
+*/
+function createTRPCOptionsResult(value) {
+	const path = value.path.join(".");
+	return { path };
+}
+/**
+* @internal
+*/
+function getClientArgs(queryKey, opts, infiniteParams) {
+	const path = queryKey[0];
+	let input = queryKey[1]?.input;
+	if (infiniteParams) input = {
+		...input ?? {},
+		...infiniteParams.pageParam !== void 0 ? { cursor: infiniteParams.pageParam } : {},
+		direction: infiniteParams.direction
+	};
+	return [
+		path.join("."),
+		input,
+		opts?.trpc
+	];
+}
+/**
+* @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;
+}
+/**
+* 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.
+*
+* @internal
+*/
+function getQueryKeyInternal(path, input, type) {
+	const splitPath = path.flatMap((part) => part.split("."));
+	if (!input && (!type || type === "any")) return splitPath.length ? [splitPath] : [];
+	if (type === "infinite" && (0, __trpc_server_unstable_core_do_not_import.isObject)(input) && ("direction" in input || "cursor" in input)) {
+		const { cursor: _, direction: __,...inputWithoutCursorAndDirection } = input;
+		return [splitPath, {
+			input: inputWithoutCursorAndDirection,
+			type: "infinite"
+		}];
+	}
+	return [splitPath, {
+		...typeof input !== "undefined" && input !== __tanstack_react_query.skipToken && { input },
+		...type && type !== "any" && { type }
+	}];
+}
+/**
+* @internal
+*/
+function getMutationKeyInternal(path) {
+	const splitPath = path.flatMap((part) => part.split("."));
+	return splitPath.length ? [splitPath] : [];
+}
+/**
+* @internal
+*/
+function unwrapLazyArg(valueOrLazy) {
+	return (0, __trpc_server_unstable_core_do_not_import.isFunction)(valueOrLazy) ? valueOrLazy() : valueOrLazy;
+}
+
+//#endregion
+//#region src/internals/infiniteQueryOptions.ts
+function trpcInfiniteQueryOptions(args) {
+	const { input, query, path, queryKey, opts } = args;
+	const inputIsSkipToken = input === __tanstack_react_query.skipToken;
+	const queryFn = async (queryFnContext) => {
+		const actualOpts = {
+			...opts,
+			trpc: {
+				...opts?.trpc,
+				...opts?.trpc?.abortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
+			}
+		};
+		const result = await query(...getClientArgs(queryKey, actualOpts, {
+			direction: queryFnContext.direction,
+			pageParam: queryFnContext.pageParam
+		}));
+		return result;
+	};
+	return Object.assign((0, __tanstack_react_query.infiniteQueryOptions)({
+		...opts,
+		queryKey,
+		queryFn: inputIsSkipToken ? __tanstack_react_query.skipToken : queryFn,
+		initialPageParam: opts?.initialCursor ?? input?.cursor
+	}), { trpc: createTRPCOptionsResult({ path }) });
+}
+
+//#endregion
+//#region src/internals/mutationOptions.ts
+/**
+* @internal
+*/
+function trpcMutationOptions(args) {
+	const { mutate, path, opts, overrides } = args;
+	const queryClient = unwrapLazyArg(args.queryClient);
+	const mutationKey = getMutationKeyInternal(path);
+	const defaultOpts = queryClient.defaultMutationOptions(queryClient.getMutationDefaults(mutationKey));
+	const mutationSuccessOverride = overrides?.onSuccess ?? ((options) => options.originalFn());
+	const mutationFn = async (input) => {
+		const result = await mutate(...getClientArgs([path, { input }], opts));
+		return result;
+	};
+	return {
+		...opts,
+		mutationKey,
+		mutationFn,
+		onSuccess(...args$1) {
+			const originalFn = () => opts?.onSuccess?.(...args$1) ?? defaultOpts?.onSuccess?.(...args$1);
+			return mutationSuccessOverride({
+				originalFn,
+				queryClient,
+				meta: opts?.meta ?? defaultOpts?.meta ?? {}
+			});
+		},
+		trpc: createTRPCOptionsResult({ path })
+	};
+}
+
+//#endregion
+//#region src/internals/queryOptions.ts
+/**
+* @internal
+*/
+function trpcQueryOptions(args) {
+	const { input, query, path, queryKey, opts } = args;
+	const queryClient = unwrapLazyArg(args.queryClient);
+	const inputIsSkipToken = input === __tanstack_react_query.skipToken;
+	const queryFn = async (queryFnContext) => {
+		const actualOpts = {
+			...opts,
+			trpc: {
+				...opts?.trpc,
+				...opts?.trpc?.abortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
+			}
+		};
+		const queryKey$1 = queryFnContext.queryKey;
+		const result = await query(...getClientArgs(queryKey$1, actualOpts));
+		if ((0, __trpc_server_unstable_core_do_not_import.isAsyncIterable)(result)) return buildQueryFromAsyncIterable(result, queryClient, queryKey$1);
+		return result;
+	};
+	return Object.assign((0, __tanstack_react_query.queryOptions)({
+		...opts,
+		queryKey,
+		queryFn: inputIsSkipToken ? __tanstack_react_query.skipToken : queryFn
+	}), { trpc: createTRPCOptionsResult({ path }) });
+}
+
+//#endregion
+//#region src/internals/subscriptionOptions.ts
+/**
+* @internal
+*/
+const trpcSubscriptionOptions = (args) => {
+	const { subscribe, path, queryKey, opts = {} } = args;
+	const input = queryKey[1]?.input;
+	const enabled = "enabled" in opts ? !!opts.enabled : input !== __tanstack_react_query.skipToken;
+	const _subscribe = (innerOpts) => {
+		return subscribe(path.join("."), input ?? void 0, innerOpts);
+	};
+	return {
+		...opts,
+		enabled,
+		subscribe: _subscribe,
+		queryKey,
+		trpc: createTRPCOptionsResult({ path })
+	};
+};
+function useSubscription(opts) {
+	const optsRef = react.useRef(opts);
+	optsRef.current = opts;
+	const trackedProps = react.useRef(new Set([]));
+	const addTrackedProp = react.useCallback((key) => {
+		trackedProps.current.add(key);
+	}, []);
+	const currentSubscriptionRef = react.useRef(() => {});
+	const reset = react.useCallback(() => {
+		currentSubscriptionRef.current?.();
+		updateState(getInitialState);
+		if (!opts.enabled) return;
+		const subscription = opts.subscribe({
+			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) => {
+				optsRef.current.onConnectionStateChange?.(result);
+				updateState((prev) => {
+					switch (result.state) {
+						case "connecting": return {
+							...prev,
+							status: "connecting",
+							error: result.error
+						};
+						case "pending": return prev;
+						case "idle": return {
+							...prev,
+							status: "idle",
+							data: void 0,
+							error: null
+						};
+					}
+				});
+			}
+		});
+		currentSubscriptionRef.current = () => {
+			subscription.unsubscribe();
+		};
+	}, [(0, __tanstack_react_query.hashKey)(opts.queryKey), opts.enabled]);
+	const getInitialState = react.useCallback(() => {
+		return opts.enabled ? {
+			data: void 0,
+			error: null,
+			status: "connecting",
+			reset
+		} : {
+			data: void 0,
+			error: null,
+			status: "idle",
+			reset
+		};
+	}, [opts.enabled, reset]);
+	const resultRef = react.useRef(getInitialState());
+	const [state, setState] = react.useState(trackResult(resultRef.current, addTrackedProp));
+	state.reset = reset;
+	const updateState = react.useCallback((callback) => {
+		const prev = resultRef.current;
+		const next = resultRef.current = callback(prev);
+		let shouldUpdate = false;
+		for (const key of trackedProps.current) if (prev[key] !== next[key]) {
+			shouldUpdate = true;
+			break;
+		}
+		if (shouldUpdate) setState(trackResult(next, addTrackedProp));
+	}, [addTrackedProp]);
+	react.useEffect(() => {
+		if (!opts.enabled) return;
+		reset();
+		return () => {
+			currentSubscriptionRef.current?.();
+		};
+	}, [reset, opts.enabled]);
+	return state;
+}
+function trackResult(result, onTrackResult) {
+	const trackedResult = new Proxy(result, { get(target, prop) {
+		onTrackResult(prop);
+		return target[prop];
+	} });
+	return trackedResult;
+}
+
+//#endregion
+//#region src/internals/createOptionsProxy.ts
+/**
+* Create a typed proxy from your router types. Can also be used on the server.
+*
+* @see https://trpc.io/docs/client/tanstack-react-query/setup#3b-setup-without-react-context
+* @see https://trpc.io/docs/client/tanstack-react-query/server-components#5-create-a-trpc-caller-for-server-components
+*/
+function createTRPCOptionsProxy(opts) {
+	const callIt = (type) => {
+		return (path, input, trpcOpts) => {
+			if ("router" in opts) return Promise.resolve(unwrapLazyArg(opts.ctx)).then((ctx) => (0, __trpc_server.callTRPCProcedure)({
+				router: opts.router,
+				path,
+				getRawInput: async () => input,
+				ctx,
+				type,
+				signal: void 0
+			}));
+			const untypedClient = opts.client instanceof __trpc_client.TRPCUntypedClient ? opts.client : (0, __trpc_client.getUntypedClient)(opts.client);
+			return untypedClient[type](path, input, trpcOpts);
+		};
+	};
+	return (0, __trpc_server.createTRPCRecursiveProxy)(({ args, path: _path }) => {
+		const path = [..._path];
+		const utilName = path.pop();
+		const [arg1, arg2] = args;
+		const contextMap = {
+			"~types": void 0,
+			pathKey: () => {
+				return getQueryKeyInternal(path);
+			},
+			pathFilter: () => {
+				return {
+					...arg1,
+					queryKey: getQueryKeyInternal(path)
+				};
+			},
+			queryOptions: () => {
+				return trpcQueryOptions({
+					input: arg1,
+					opts: arg2,
+					path,
+					queryClient: opts.queryClient,
+					queryKey: getQueryKeyInternal(path, arg1, "query"),
+					query: callIt("query")
+				});
+			},
+			queryKey: () => {
+				return getQueryKeyInternal(path, arg1, "query");
+			},
+			queryFilter: () => {
+				return {
+					...arg2,
+					queryKey: getQueryKeyInternal(path, arg1, "query")
+				};
+			},
+			infiniteQueryOptions: () => {
+				return trpcInfiniteQueryOptions({
+					input: arg1,
+					opts: arg2,
+					path,
+					queryClient: opts.queryClient,
+					queryKey: getQueryKeyInternal(path, arg1, "infinite"),
+					query: callIt("query")
+				});
+			},
+			infiniteQueryKey: () => {
+				return getQueryKeyInternal(path, arg1, "infinite");
+			},
+			infiniteQueryFilter: () => {
+				return {
+					...arg2,
+					queryKey: getQueryKeyInternal(path, arg1, "infinite")
+				};
+			},
+			mutationOptions: () => {
+				return trpcMutationOptions({
+					opts: arg1,
+					path,
+					queryClient: opts.queryClient,
+					mutate: callIt("mutation"),
+					overrides: opts.overrides?.mutations
+				});
+			},
+			mutationKey: () => {
+				return getMutationKeyInternal(path);
+			},
+			subscriptionOptions: () => {
+				return trpcSubscriptionOptions({
+					opts: arg2,
+					path,
+					queryKey: getQueryKeyInternal(path, arg1, "any"),
+					subscribe: callIt("subscription")
+				});
+			}
+		};
+		return contextMap[utilName]();
+	});
+}
+
+//#endregion
+//#region src/internals/Context.tsx
+/**
+* Create a set of type-safe provider-consumers
+*
+* @see https://trpc.io/docs/client/tanstack-react-query/setup#3a-setup-the-trpc-context-provider
+*/
+function createTRPCContext() {
+	const TRPCClientContext = react.createContext(null);
+	const TRPCContext = react.createContext(null);
+	function TRPCProvider(props) {
+		const value = react.useMemo(() => createTRPCOptionsProxy({
+			client: props.trpcClient,
+			queryClient: props.queryClient
+		}), [props.trpcClient, props.queryClient]);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TRPCClientContext.Provider, {
+			value: props.trpcClient,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TRPCContext.Provider, {
+				value,
+				children: props.children
+			})
+		});
+	}
+	function useTRPC() {
+		const utils = react.useContext(TRPCContext);
+		if (!utils) throw new Error("useTRPC() can only be used inside of a <TRPCProvider>");
+		return utils;
+	}
+	function useTRPCClient() {
+		const client = react.useContext(TRPCClientContext);
+		if (!client) throw new Error("useTRPCClient() can only be used inside of a <TRPCProvider>");
+		return client;
+	}
+	return {
+		TRPCProvider,
+		useTRPC,
+		useTRPCClient
+	};
+}
+
+//#endregion
+exports.createTRPCContext = createTRPCContext;
+exports.createTRPCOptionsProxy = createTRPCOptionsProxy;
+exports.useSubscription = useSubscription;