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

package/dist/server/index.mjs

@@ -1,3 +1,133 @@
-import { createServerSideHelpers } from "./ssgProxy.mjs";
+import { getQueryKeyInternal } from "../getQueryKey-Dekty44G.mjs";
+import { getQueryClient, getQueryType } from "../shared-CMPBsqju.mjs";
+import { TRPCUntypedClient, getUntypedClient } from "@trpc/client";
+import { dehydrate } from "@tanstack/react-query";
+import { callProcedure, createFlatProxy, createRecursiveProxy, run } from "@trpc/server/unstable-core-do-not-import";
+import { getTransformer } from "@trpc/client/unstable-internals";
 
-export { createServerSideHelpers };
+//#region src/server/ssgProxy.ts
+/**
+* Create functions you can use for server-side rendering / static generation
+* @see https://trpc.io/docs/v11/client/nextjs/server-side-helpers
+*/
+function createServerSideHelpers(opts) {
+	const queryClient = getQueryClient(opts);
+	const transformer = getTransformer(opts.transformer);
+	const resolvedOpts = (() => {
+		if ("router" in opts) {
+			const { ctx, router } = opts;
+			return {
+				serialize: transformer.output.serialize,
+				query: (queryOpts) => {
+					return callProcedure({
+						router,
+						path: queryOpts.path,
+						getRawInput: async () => queryOpts.input,
+						ctx,
+						type: "query",
+						signal: void 0
+					});
+				}
+			};
+		}
+		const { client } = opts;
+		const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+		return {
+			query: (queryOpts) => untypedClient.query(queryOpts.path, queryOpts.input),
+			serialize: (obj) => transformer.output.serialize(obj)
+		};
+	})();
+	function _dehydrate(opts$1 = { shouldDehydrateQuery(query) {
+		if (query.state.status === "pending") return false;
+		return true;
+	} }) {
+		const before = run(() => {
+			const dehydrated = dehydrate(queryClient, opts$1);
+			return {
+				...dehydrated,
+				queries: dehydrated.queries.map((query) => {
+					if (query.promise) {
+						const { promise: _,...rest } = query;
+						return rest;
+					}
+					return query;
+				})
+			};
+		});
+		const after = resolvedOpts.serialize(before);
+		return after;
+	}
+	const proxy = createRecursiveProxy((opts$1) => {
+		const args = opts$1.args;
+		const input = args[0];
+		const arrayPath = [...opts$1.path];
+		const utilName = arrayPath.pop();
+		const queryFn = () => resolvedOpts.query({
+			path: arrayPath.join("."),
+			input
+		});
+		const queryKey = getQueryKeyInternal(arrayPath, input, getQueryType(utilName));
+		const helperMap = {
+			queryOptions: () => {
+				const args1 = args[1];
+				return {
+					...args1,
+					queryKey,
+					queryFn
+				};
+			},
+			infiniteQueryOptions: () => {
+				const args1 = args[1];
+				return {
+					...args1,
+					queryKey,
+					queryFn
+				};
+			},
+			fetch: () => {
+				const args1 = args[1];
+				return queryClient.fetchQuery({
+					...args1,
+					queryKey,
+					queryFn
+				});
+			},
+			fetchInfinite: () => {
+				const args1 = args[1];
+				return queryClient.fetchInfiniteQuery({
+					...args1,
+					queryKey,
+					queryFn,
+					initialPageParam: args1?.initialCursor ?? null
+				});
+			},
+			prefetch: () => {
+				const args1 = args[1];
+				return queryClient.prefetchQuery({
+					...args1,
+					queryKey,
+					queryFn
+				});
+			},
+			prefetchInfinite: () => {
+				const args1 = args[1];
+				return queryClient.prefetchInfiniteQuery({
+					...args1,
+					queryKey,
+					queryFn,
+					initialPageParam: args1?.initialCursor ?? null
+				});
+			}
+		};
+		return helperMap[utilName]();
+	});
+	return createFlatProxy((key) => {
+		if (key === "queryClient") return queryClient;
+		if (key === "dehydrate") return _dehydrate;
+		return proxy[key];
+	});
+}
+
+//#endregion
+export { createServerSideHelpers };
+//# sourceMappingURL=index.mjs.map

package/dist/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["opts: CreateServerSideHelpersOptions<TRouter>","resolvedOpts: {\n    serialize: (obj: unknown) => any;\n    query: (queryOpts: { path: string; input: unknown }) => Promise<unknown>;\n  }","opts: DehydrateOptions","opts","helperMap: Record<keyof AnyDecoratedProcedure, () => unknown>"],"sources":["../../src/server/ssgProxy.ts"],"sourcesContent":["import type {\n  DehydratedState,\n  DehydrateOptions,\n  QueryClient,\n} from '@tanstack/react-query';\nimport { dehydrate } from '@tanstack/react-query';\nimport type { TRPCClient } from '@trpc/client';\nimport { getUntypedClient, TRPCUntypedClient } from '@trpc/client';\nimport type { CoercedTransformerParameters } from '@trpc/client/unstable-internals';\nimport {\n  getTransformer,\n  type TransformerOptions,\n} from '@trpc/client/unstable-internals';\nimport type {\n  AnyQueryProcedure,\n  AnyRootTypes,\n  AnyRouter,\n  inferClientTypes,\n  inferRouterContext,\n  Maybe,\n  ProtectedIntersection,\n  RouterRecord,\n} from '@trpc/server/unstable-core-do-not-import';\nimport {\n  callProcedure,\n  createFlatProxy,\n  createRecursiveProxy,\n  run,\n} from '@trpc/server/unstable-core-do-not-import';\nimport { getQueryKeyInternal } from '../internals/getQueryKey';\nimport type {\n  CreateTRPCReactQueryClientConfig,\n  DecorateQueryProcedure,\n  TRPCFetchInfiniteQueryOptions,\n  TRPCFetchQueryOptions,\n} from '../shared';\nimport { getQueryClient, getQueryType } from '../shared';\n\ntype CreateSSGHelpersInternal<TRouter extends AnyRouter> = {\n  router: TRouter;\n  ctx: inferRouterContext<TRouter>;\n} & TransformerOptions<inferClientTypes<TRouter>>;\n\ninterface CreateSSGHelpersExternal<TRouter extends AnyRouter> {\n  client: TRPCClient<TRouter> | TRPCUntypedClient<TRouter>;\n}\n\ntype CreateServerSideHelpersOptions<TRouter extends AnyRouter> =\n  CreateTRPCReactQueryClientConfig &\n    (CreateSSGHelpersExternal<TRouter> | CreateSSGHelpersInternal<TRouter>);\n\ntype SSGFns =\n  | 'queryOptions'\n  | 'infiniteQueryOptions'\n  | 'fetch'\n  | 'fetchInfinite'\n  | 'prefetch'\n  | 'prefetchInfinite';\n\n/**\n * @internal\n */\ntype DecoratedProcedureSSGRecord<\n  TRoot extends AnyRootTypes,\n  TRecord extends RouterRecord,\n> = {\n  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value\n    ? $Value extends AnyQueryProcedure\n      ? Pick<DecorateQueryProcedure<TRoot, $Value>, SSGFns>\n      : $Value extends RouterRecord\n        ? DecoratedProcedureSSGRecord<TRoot, $Value>\n        : never\n    : never;\n};\n\ntype AnyDecoratedProcedure = Pick<DecorateQueryProcedure<any, any>, SSGFns>;\n\n/**\n * Create functions you can use for server-side rendering / static generation\n * @see https://trpc.io/docs/v11/client/nextjs/server-side-helpers\n */\nexport function createServerSideHelpers<TRouter extends AnyRouter>(\n  opts: CreateServerSideHelpersOptions<TRouter>,\n) {\n  const queryClient = getQueryClient(opts);\n  const transformer = getTransformer(\n    (opts as CoercedTransformerParameters).transformer,\n  );\n\n  const resolvedOpts: {\n    serialize: (obj: unknown) => any;\n    query: (queryOpts: { path: string; input: unknown }) => Promise<unknown>;\n  } = (() => {\n    if ('router' in opts) {\n      const { ctx, router } = opts;\n      return {\n        serialize: transformer.output.serialize,\n        query: (queryOpts) => {\n          return callProcedure({\n            router,\n            path: queryOpts.path,\n            getRawInput: async () => queryOpts.input,\n            ctx,\n            type: 'query',\n            signal: undefined,\n          });\n        },\n      };\n    }\n\n    const { client } = opts;\n    const untypedClient =\n      client instanceof TRPCUntypedClient ? client : getUntypedClient(client);\n\n    return {\n      query: (queryOpts) =>\n        untypedClient.query(queryOpts.path, queryOpts.input),\n      serialize: (obj) => transformer.output.serialize(obj),\n    };\n  })();\n\n  function _dehydrate(\n    opts: DehydrateOptions = {\n      shouldDehydrateQuery(query) {\n        if (query.state.status === 'pending') {\n          return false;\n        }\n        // makes sure to serialize errors\n        return true;\n      },\n    },\n  ): DehydratedState {\n    const before = run(() => {\n      const dehydrated = dehydrate(queryClient, opts);\n\n      return {\n        ...dehydrated,\n        queries: dehydrated.queries.map((query) => {\n          if (query.promise) {\n            const { promise: _, ...rest } = query;\n            return rest;\n          }\n          return query;\n        }),\n      };\n    });\n    const after = resolvedOpts.serialize(before);\n    return after;\n  }\n\n  type CreateSSGHelpers = ProtectedIntersection<\n    {\n      queryClient: QueryClient;\n      dehydrate: (opts?: DehydrateOptions) => DehydratedState;\n    },\n    DecoratedProcedureSSGRecord<\n      TRouter['_def']['_config']['$types'],\n      TRouter['_def']['record']\n    >\n  >;\n  const proxy = createRecursiveProxy<CreateSSGHelpers>((opts) => {\n    const args = opts.args;\n    const input = args[0];\n    const arrayPath = [...opts.path];\n    const utilName = arrayPath.pop() as keyof AnyDecoratedProcedure;\n\n    const queryFn = () =>\n      resolvedOpts.query({ path: arrayPath.join('.'), input });\n\n    const queryKey = getQueryKeyInternal(\n      arrayPath,\n      input,\n      getQueryType(utilName),\n    );\n\n    const helperMap: Record<keyof AnyDecoratedProcedure, () => unknown> = {\n      queryOptions: () => {\n        const args1 = args[1] as Maybe<any>;\n        return { ...args1, queryKey, queryFn };\n      },\n      infiniteQueryOptions: () => {\n        const args1 = args[1] as Maybe<any>;\n        return { ...args1, queryKey, queryFn };\n      },\n      fetch: () => {\n        const args1 = args[1] as Maybe<TRPCFetchQueryOptions<any, any>>;\n        return queryClient.fetchQuery({ ...args1, queryKey, queryFn });\n      },\n      fetchInfinite: () => {\n        const args1 = args[1] as Maybe<\n          TRPCFetchInfiniteQueryOptions<any, any, any>\n        >;\n        return queryClient.fetchInfiniteQuery({\n          ...args1,\n          queryKey,\n          queryFn,\n          initialPageParam: args1?.initialCursor ?? null,\n        });\n      },\n      prefetch: () => {\n        const args1 = args[1] as Maybe<TRPCFetchQueryOptions<any, any>>;\n        return queryClient.prefetchQuery({ ...args1, queryKey, queryFn });\n      },\n      prefetchInfinite: () => {\n        const args1 = args[1] as Maybe<\n          TRPCFetchInfiniteQueryOptions<any, any, any>\n        >;\n        return queryClient.prefetchInfiniteQuery({\n          ...args1,\n          queryKey,\n          queryFn,\n          initialPageParam: args1?.initialCursor ?? null,\n        });\n      },\n    };\n\n    return helperMap[utilName]();\n  });\n  return createFlatProxy<CreateSSGHelpers>((key) => {\n    if (key === 'queryClient') return queryClient;\n    if (key === 'dehydrate') return _dehydrate;\n    return proxy[key];\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAiFA,SAAgB,wBACdA,MACA;CACA,MAAM,cAAc,eAAe,KAAK;CACxC,MAAM,cAAc,eACjB,KAAsC,YACxC;CAED,MAAMC,eAGF,CAAC,MAAM;AACT,MAAI,YAAY,MAAM;GACpB,MAAM,EAAE,KAAK,QAAQ,GAAG;AACxB,UAAO;IACL,WAAW,YAAY,OAAO;IAC9B,OAAO,CAAC,cAAc;AACpB,YAAO,cAAc;MACnB;MACA,MAAM,UAAU;MAChB,aAAa,YAAY,UAAU;MACnC;MACA,MAAM;MACN;KACD,EAAC;IACH;GACF;EACF;EAED,MAAM,EAAE,QAAQ,GAAG;EACnB,MAAM,gBACJ,kBAAkB,oBAAoB,SAAS,iBAAiB,OAAO;AAEzE,SAAO;GACL,OAAO,CAAC,cACN,cAAc,MAAM,UAAU,MAAM,UAAU,MAAM;GACtD,WAAW,CAAC,QAAQ,YAAY,OAAO,UAAU,IAAI;EACtD;CACF,IAAG;CAEJ,SAAS,WACPC,SAAyB,EACvB,qBAAqB,OAAO;AAC1B,MAAI,MAAM,MAAM,WAAW,UACzB,QAAO;AAGT,SAAO;CACR,EACF,GACgB;EACjB,MAAM,SAAS,IAAI,MAAM;GACvB,MAAM,aAAa,UAAU,aAAaC,OAAK;AAE/C,UAAO;IACL,GAAG;IACH,SAAS,WAAW,QAAQ,IAAI,CAAC,UAAU;AACzC,SAAI,MAAM,SAAS;MACjB,MAAM,EAAE,SAAS,EAAG,GAAG,MAAM,GAAG;AAChC,aAAO;KACR;AACD,YAAO;IACR,EAAC;GACH;EACF,EAAC;EACF,MAAM,QAAQ,aAAa,UAAU,OAAO;AAC5C,SAAO;CACR;CAYD,MAAM,QAAQ,qBAAuC,CAACA,WAAS;EAC7D,MAAM,OAAOA,OAAK;EAClB,MAAM,QAAQ,KAAK;EACnB,MAAM,YAAY,CAAC,GAAGA,OAAK,IAAK;EAChC,MAAM,WAAW,UAAU,KAAK;EAEhC,MAAM,UAAU,MACd,aAAa,MAAM;GAAE,MAAM,UAAU,KAAK,IAAI;GAAE;EAAO,EAAC;EAE1D,MAAM,WAAW,oBACf,WACA,OACA,aAAa,SAAS,CACvB;EAED,MAAMC,YAAgE;GACpE,cAAc,MAAM;IAClB,MAAM,QAAQ,KAAK;AACnB,WAAO;KAAE,GAAG;KAAO;KAAU;IAAS;GACvC;GACD,sBAAsB,MAAM;IAC1B,MAAM,QAAQ,KAAK;AACnB,WAAO;KAAE,GAAG;KAAO;KAAU;IAAS;GACvC;GACD,OAAO,MAAM;IACX,MAAM,QAAQ,KAAK;AACnB,WAAO,YAAY,WAAW;KAAE,GAAG;KAAO;KAAU;IAAS,EAAC;GAC/D;GACD,eAAe,MAAM;IACnB,MAAM,QAAQ,KAAK;AAGnB,WAAO,YAAY,mBAAmB;KACpC,GAAG;KACH;KACA;KACA,kBAAkB,OAAO,iBAAiB;IAC3C,EAAC;GACH;GACD,UAAU,MAAM;IACd,MAAM,QAAQ,KAAK;AACnB,WAAO,YAAY,cAAc;KAAE,GAAG;KAAO;KAAU;IAAS,EAAC;GAClE;GACD,kBAAkB,MAAM;IACtB,MAAM,QAAQ,KAAK;AAGnB,WAAO,YAAY,sBAAsB;KACvC,GAAG;KACH;KACA;KACA,kBAAkB,OAAO,iBAAiB;IAC3C,EAAC;GACH;EACF;AAED,SAAO,UAAU,WAAW;CAC7B,EAAC;AACF,QAAO,gBAAkC,CAAC,QAAQ;AAChD,MAAI,QAAQ,cAAe,QAAO;AAClC,MAAI,QAAQ,YAAa,QAAO;AAChC,SAAO,MAAM;CACd,EAAC;AACH"}

package/dist/shared/index.cjs

@@ -0,0 +1,13 @@
+require('../getQueryKey-CP8onRYT.cjs');
+const require_shared = require('../shared-Doe-Gsbv.cjs');
+
+exports.TRPCContext = require_shared.TRPCContext;
+exports.contextProps = require_shared.contextProps;
+exports.createQueryUtilsProxy = require_shared.createQueryUtilsProxy;
+exports.createReactDecoration = require_shared.createReactDecoration;
+exports.createReactQueryUtils = require_shared.createReactQueryUtils;
+exports.createRootHooks = require_shared.createRootHooks;
+exports.createUseQueries = require_shared.createUseQueries;
+exports.getClientArgs = require_shared.getClientArgs;
+exports.getQueryClient = require_shared.getQueryClient;
+exports.getQueryType = require_shared.getQueryType;

package/dist/shared/index.d.cts

@@ -0,0 +1,2 @@
+import { CreateClient, CreateQueryUtils, CreateReactUtils, CreateTRPCReactOptions, CreateTRPCReactQueryClientConfig, DecorateProcedure, DecorateQueryProcedure, DecorateRouterRecord, DecoratedProcedureUtilsRecord, DecoratedTRPCContextProps, DefinedTRPCInfiniteQueryOptionsIn, DefinedTRPCInfiniteQueryOptionsOut, DefinedTRPCQueryOptionsIn, DefinedTRPCQueryOptionsOut, DefinedUseTRPCQueryOptions, DefinedUseTRPCQueryResult, ExtractCursorType, InferMutationLikeData, InferMutationLikeInput, InferQueryLikeData, InferQueryLikeInput, MutationLike, OutputWithCursor, QueryLike, RouterLike, RouterLikeInner, SSRState, TRPCContext, TRPCContextProps, TRPCContextPropsBase, TRPCContextState, TRPCFetchInfiniteQueryOptions, TRPCFetchQueryOptions, TRPCHookResult, TRPCProvider, TRPCProviderProps, TRPCQueryBaseOptions, TRPCQueryOptions, TRPCQueryOptionsResult, TRPCQueryUtils, TRPCReactRequestOptions, TRPCSubscriptionBaseResult, TRPCSubscriptionConnectingResult, TRPCSubscriptionErrorResult, TRPCSubscriptionIdleResult, TRPCSubscriptionPendingResult, TRPCSubscriptionResult, TRPCUseQueries, TRPCUseQueryBaseOptions, TRPCUseSuspenseQueries, UndefinedTRPCInfiniteQueryOptionsIn, UndefinedTRPCInfiniteQueryOptionsOut, UndefinedTRPCQueryOptionsIn, UndefinedTRPCQueryOptionsOut, UnusedSkipTokenTRPCInfiniteQueryOptionsIn, UnusedSkipTokenTRPCInfiniteQueryOptionsOut, UnusedSkipTokenTRPCQueryOptionsIn, UnusedSkipTokenTRPCQueryOptionsOut, UseMutationOverride, UseQueriesProcedureRecord, UseSuspenseQueriesProcedureRecord, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCInfiniteQuerySuccessResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCPrefetchInfiniteQueryOptions, UseTRPCPrefetchQueryOptions, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCQuerySuccessResult, UseTRPCSubscriptionOptions, UseTRPCSuspenseInfiniteQueryOptions, UseTRPCSuspenseInfiniteQueryResult, UseTRPCSuspenseQueryOptions, UseTRPCSuspenseQueryResult, UtilsLike, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType } from "../getQueryKey.d-C_PnqPni.cjs";
+export { CreateClient, CreateQueryUtils, CreateReactUtils, CreateTRPCReactOptions, CreateTRPCReactQueryClientConfig, DecorateProcedure, DecorateQueryProcedure, DecorateRouterRecord, DecoratedProcedureUtilsRecord, DecoratedTRPCContextProps, DefinedTRPCInfiniteQueryOptionsIn, DefinedTRPCInfiniteQueryOptionsOut, DefinedTRPCQueryOptionsIn, DefinedTRPCQueryOptionsOut, DefinedUseTRPCQueryOptions, DefinedUseTRPCQueryResult, ExtractCursorType, InferMutationLikeData, InferMutationLikeInput, InferQueryLikeData, InferQueryLikeInput, MutationLike, OutputWithCursor, QueryLike, RouterLike, RouterLikeInner, SSRState, TRPCContext, TRPCContextProps, TRPCContextPropsBase, TRPCContextState, TRPCFetchInfiniteQueryOptions, TRPCFetchQueryOptions, TRPCHookResult, TRPCProvider, TRPCProviderProps, TRPCQueryBaseOptions, TRPCQueryOptions, TRPCQueryOptionsResult, TRPCQueryUtils, TRPCReactRequestOptions, TRPCSubscriptionBaseResult, TRPCSubscriptionConnectingResult, TRPCSubscriptionErrorResult, TRPCSubscriptionIdleResult, TRPCSubscriptionPendingResult, TRPCSubscriptionResult, TRPCUseQueries, TRPCUseQueryBaseOptions, TRPCUseSuspenseQueries, UndefinedTRPCInfiniteQueryOptionsIn, UndefinedTRPCInfiniteQueryOptionsOut, UndefinedTRPCQueryOptionsIn, UndefinedTRPCQueryOptionsOut, UnusedSkipTokenTRPCInfiniteQueryOptionsIn, UnusedSkipTokenTRPCInfiniteQueryOptionsOut, UnusedSkipTokenTRPCQueryOptionsIn, UnusedSkipTokenTRPCQueryOptionsOut, UseMutationOverride, UseQueriesProcedureRecord, UseSuspenseQueriesProcedureRecord, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCInfiniteQuerySuccessResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCPrefetchInfiniteQueryOptions, UseTRPCPrefetchQueryOptions, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCQuerySuccessResult, UseTRPCSubscriptionOptions, UseTRPCSuspenseInfiniteQueryOptions, UseTRPCSuspenseInfiniteQueryResult, UseTRPCSuspenseQueryOptions, UseTRPCSuspenseQueryResult, UtilsLike, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType };

package/dist/shared/index.d.mts

@@ -1,16 +1,2 @@
-import { DecoratedTRPCContextProps, SSRState, TRPCContext$1 as TRPCContext, TRPCContextProps, TRPCContextPropsBase, TRPCContextState, TRPCFetchInfiniteQueryOptions, TRPCFetchQueryOptions, TRPCQueryUtils, contextProps$1 as contextProps } from "../internals/context.mjs";
-import { CreateClient, DefinedUseTRPCQueryOptions, DefinedUseTRPCQueryResult, ExtractCursorType, OutputWithCursor, TRPCHookResult, TRPCProvider, TRPCProviderProps, TRPCQueryOptions, TRPCReactRequestOptions, TRPCSubscriptionBaseResult, TRPCSubscriptionConnectingResult, TRPCSubscriptionErrorResult, TRPCSubscriptionIdleResult, TRPCSubscriptionPendingResult, TRPCSubscriptionResult, TRPCUseQueryBaseOptions, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCInfiniteQuerySuccessResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCPrefetchInfiniteQueryOptions, UseTRPCPrefetchQueryOptions, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCQuerySuccessResult, UseTRPCSubscriptionOptions, UseTRPCSuspenseInfiniteQueryOptions, UseTRPCSuspenseInfiniteQueryResult, UseTRPCSuspenseQueryOptions, UseTRPCSuspenseQueryResult } from "./hooks/types.mjs";
-import { CreateTRPCReactOptions, DefinedTRPCInfiniteQueryOptionsIn, DefinedTRPCInfiniteQueryOptionsOut, DefinedTRPCQueryOptionsIn, DefinedTRPCQueryOptionsOut, TRPCQueryBaseOptions, TRPCQueryOptionsResult, UndefinedTRPCInfiniteQueryOptionsIn, UndefinedTRPCInfiniteQueryOptionsOut, UndefinedTRPCQueryOptionsIn, UndefinedTRPCQueryOptionsOut, UnusedSkipTokenTRPCInfiniteQueryOptionsIn, UnusedSkipTokenTRPCInfiniteQueryOptionsOut, UnusedSkipTokenTRPCQueryOptionsIn, UnusedSkipTokenTRPCQueryOptionsOut, UseMutationOverride } from "./types.mjs";
-import { createRootHooks$1 as createRootHooks } from "./hooks/createHooksInternal.mjs";
-import { createReactDecoration$1 as createReactDecoration } from "./proxy/decorationProxy.mjs";
-import { CreateQueryUtils, CreateReactUtils, DecorateQueryProcedure, DecoratedProcedureUtilsRecord, createQueryUtilsProxy$1 as createQueryUtilsProxy, createReactQueryUtils$1 as createReactQueryUtils, getQueryType$1 as getQueryType } from "./proxy/utilsProxy.mjs";
-import { UseQueriesProcedureRecord, UseSuspenseQueriesProcedureRecord, createUseQueries$1 as createUseQueries } from "./proxy/useQueriesProxy.mjs";
-import { CreateTRPCReactQueryClientConfig, getQueryClient$1 as getQueryClient } from "./queryClient.mjs";
-import { InferMutationLikeData, InferMutationLikeInput, MutationLike } from "./polymorphism/mutationLike.mjs";
-import { InferQueryLikeData, InferQueryLikeInput, QueryLike } from "./polymorphism/queryLike.mjs";
-import { RouterLike, RouterLikeInner } from "./polymorphism/routerLike.mjs";
-import { UtilsLike } from "./polymorphism/utilsLike.mjs";
-import { getClientArgs$1 as getClientArgs } from "../internals/getClientArgs.mjs";
-import { TRPCUseQueries, TRPCUseSuspenseQueries } from "../internals/useQueries.mjs";
-import { DecorateProcedure, DecorateRouterRecord } from "../createTRPCReact.mjs";
+import { CreateClient, CreateQueryUtils, CreateReactUtils, CreateTRPCReactOptions, CreateTRPCReactQueryClientConfig, DecorateProcedure, DecorateQueryProcedure, DecorateRouterRecord, DecoratedProcedureUtilsRecord, DecoratedTRPCContextProps, DefinedTRPCInfiniteQueryOptionsIn, DefinedTRPCInfiniteQueryOptionsOut, DefinedTRPCQueryOptionsIn, DefinedTRPCQueryOptionsOut, DefinedUseTRPCQueryOptions, DefinedUseTRPCQueryResult, ExtractCursorType, InferMutationLikeData, InferMutationLikeInput, InferQueryLikeData, InferQueryLikeInput, MutationLike, OutputWithCursor, QueryLike, RouterLike, RouterLikeInner, SSRState, TRPCContext, TRPCContextProps, TRPCContextPropsBase, TRPCContextState, TRPCFetchInfiniteQueryOptions, TRPCFetchQueryOptions, TRPCHookResult, TRPCProvider, TRPCProviderProps, TRPCQueryBaseOptions, TRPCQueryOptions, TRPCQueryOptionsResult, TRPCQueryUtils, TRPCReactRequestOptions, TRPCSubscriptionBaseResult, TRPCSubscriptionConnectingResult, TRPCSubscriptionErrorResult, TRPCSubscriptionIdleResult, TRPCSubscriptionPendingResult, TRPCSubscriptionResult, TRPCUseQueries, TRPCUseQueryBaseOptions, TRPCUseSuspenseQueries, UndefinedTRPCInfiniteQueryOptionsIn, UndefinedTRPCInfiniteQueryOptionsOut, UndefinedTRPCQueryOptionsIn, UndefinedTRPCQueryOptionsOut, UnusedSkipTokenTRPCInfiniteQueryOptionsIn, UnusedSkipTokenTRPCInfiniteQueryOptionsOut, UnusedSkipTokenTRPCQueryOptionsIn, UnusedSkipTokenTRPCQueryOptionsOut, UseMutationOverride, UseQueriesProcedureRecord, UseSuspenseQueriesProcedureRecord, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCInfiniteQuerySuccessResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCPrefetchInfiniteQueryOptions, UseTRPCPrefetchQueryOptions, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCQuerySuccessResult, UseTRPCSubscriptionOptions, UseTRPCSuspenseInfiniteQueryOptions, UseTRPCSuspenseInfiniteQueryResult, UseTRPCSuspenseQueryOptions, UseTRPCSuspenseQueryResult, UtilsLike, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType } from "../getQueryKey.d-CruH3ncI.mjs";
 export { CreateClient, CreateQueryUtils, CreateReactUtils, CreateTRPCReactOptions, CreateTRPCReactQueryClientConfig, DecorateProcedure, DecorateQueryProcedure, DecorateRouterRecord, DecoratedProcedureUtilsRecord, DecoratedTRPCContextProps, DefinedTRPCInfiniteQueryOptionsIn, DefinedTRPCInfiniteQueryOptionsOut, DefinedTRPCQueryOptionsIn, DefinedTRPCQueryOptionsOut, DefinedUseTRPCQueryOptions, DefinedUseTRPCQueryResult, ExtractCursorType, InferMutationLikeData, InferMutationLikeInput, InferQueryLikeData, InferQueryLikeInput, MutationLike, OutputWithCursor, QueryLike, RouterLike, RouterLikeInner, SSRState, TRPCContext, TRPCContextProps, TRPCContextPropsBase, TRPCContextState, TRPCFetchInfiniteQueryOptions, TRPCFetchQueryOptions, TRPCHookResult, TRPCProvider, TRPCProviderProps, TRPCQueryBaseOptions, TRPCQueryOptions, TRPCQueryOptionsResult, TRPCQueryUtils, TRPCReactRequestOptions, TRPCSubscriptionBaseResult, TRPCSubscriptionConnectingResult, TRPCSubscriptionErrorResult, TRPCSubscriptionIdleResult, TRPCSubscriptionPendingResult, TRPCSubscriptionResult, TRPCUseQueries, TRPCUseQueryBaseOptions, TRPCUseSuspenseQueries, UndefinedTRPCInfiniteQueryOptionsIn, UndefinedTRPCInfiniteQueryOptionsOut, UndefinedTRPCQueryOptionsIn, UndefinedTRPCQueryOptionsOut, UnusedSkipTokenTRPCInfiniteQueryOptionsIn, UnusedSkipTokenTRPCInfiniteQueryOptionsOut, UnusedSkipTokenTRPCQueryOptionsIn, UnusedSkipTokenTRPCQueryOptionsOut, UseMutationOverride, UseQueriesProcedureRecord, UseSuspenseQueriesProcedureRecord, UseTRPCInfiniteQueryOptions, UseTRPCInfiniteQueryResult, UseTRPCInfiniteQuerySuccessResult, UseTRPCMutationOptions, UseTRPCMutationResult, UseTRPCPrefetchInfiniteQueryOptions, UseTRPCPrefetchQueryOptions, UseTRPCQueryOptions, UseTRPCQueryResult, UseTRPCQuerySuccessResult, UseTRPCSubscriptionOptions, UseTRPCSuspenseInfiniteQueryOptions, UseTRPCSuspenseInfiniteQueryResult, UseTRPCSuspenseQueryOptions, UseTRPCSuspenseQueryResult, UtilsLike, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType };

package/dist/shared/index.mjs

@@ -1,9 +1,4 @@
-import { createReactDecoration } from "./proxy/decorationProxy.mjs";
-import { TRPCContext, contextProps } from "../internals/context.mjs";
-import { createQueryUtilsProxy, createReactQueryUtils, getQueryType } from "./proxy/utilsProxy.mjs";
-import { createUseQueries } from "./proxy/useQueriesProxy.mjs";
-import { getClientArgs } from "../internals/getClientArgs.mjs";
-import { createRootHooks } from "./hooks/createHooksInternal.mjs";
-import { getQueryClient } from "./queryClient.mjs";
+import "../getQueryKey-Dekty44G.mjs";
+import { TRPCContext, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType } from "../shared-CMPBsqju.mjs";
 
 export { TRPCContext, contextProps, createQueryUtilsProxy, createReactDecoration, createReactQueryUtils, createRootHooks, createUseQueries, getClientArgs, getQueryClient, getQueryType };

package/dist/{shared/hooks/createHooksInternal.mjs → shared-CMPBsqju.mjs}

@@ -1,15 +1,360 @@
-import { getMutationKeyInternal, getQueryKeyInternal } from "../../internals/getQueryKey.mjs";
-import { TRPCContext } from "../../internals/context.mjs";
-import { createUseQueries } from "../proxy/useQueriesProxy.mjs";
-import { getClientArgs } from "../../internals/getClientArgs.mjs";
-import { buildQueryFromAsyncIterable, useHookResult } from "../../internals/trpcResult.mjs";
-import { createUtilityFunctions } from "../../utils/createUtilityFunctions.mjs";
-import { TRPCUntypedClient, createTRPCClient, getUntypedClient } from "@trpc/client";
-import { hashKey, skipToken, useInfiniteQuery, useMutation, usePrefetchInfiniteQuery, usePrefetchQuery, useQueries, useQuery, useSuspenseInfiniteQuery, useSuspenseQueries, useSuspenseQuery } from "@tanstack/react-query";
-import { isAsyncIterable } from "@trpc/server/unstable-core-do-not-import";
+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) {
@@ -428,5 +773,12 @@ function createRootHooks(config) {
 }
 
 //#endregion
-export { createRootHooks };
-//# sourceMappingURL=createHooksInternal.mjs.map
+//#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