trpc-nuxt-module 4.4.0 → 4.5.0

package/README.md

@@ -5,7 +5,11 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-tRPC for [Nuxt](https://nuxt.com): a Nuxt module that registers your router's HTTP handler — and, when you ask for it, a WebSocket handler over Nitro's own WebSockets — fetches through the request event during server rendering so a call never leaves the process, and decorates the typed client with `useQuery`, `useLazyQuery`, `useMutation` and `useSubscription`, each a composable over Nuxt's own `useAsyncData`.
+tRPC for [Nuxt](https://nuxt.com). This module does the following:
+
+- It registers the router's HTTP handler, and a WebSocket handler over Nitro's own WebSockets when you enable it.
+- During server rendering, it fetches through the request event, so a call never leaves the process.
+- It decorates the typed client with `useQuery`, `useLazyQuery`, `useMutation` and `useSubscription`. Each is a composable over Nuxt's own `useAsyncData`.
 
 Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/trpc-nuxt-module).
 
@@ -19,11 +23,13 @@ Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/
 
 ## <a name="getting-started">🚀 Getting Started</a>
 
+1. Install the packages.
+
 ```bash
 pnpm i trpc-nuxt-module @trpc/server @trpc/client
 ```
 
-Register the module with the file and export name of your router and your context factory:
+2. Register the module in `nuxt.config.ts`. Give the file and the export name of your router and of your context factory.
 
 ```ts
 // nuxt.config.ts
@@ -39,6 +45,8 @@ export default defineNuxtConfig({
 });
 ```
 
+3. Define the router in the file that the `router` option names.
+
 ```ts
 // server/trpc/router.ts
 import { initTRPC } from "@trpc/server";
@@ -51,7 +59,7 @@ export const appRouter = t.router({ greeting: t.procedure.input(z.string()).quer
 export type AppRouter = typeof appRouter;
 ```
 
-Provide a client from a plugin — `createTRPCNuxtClient` and the links are auto-imported:
+4. Create a plugin from this code. `createTRPCNuxtClient` and the links are auto-imported. `useNuxtApp()` returns `$trpc`.
 
 ```ts
 // app/plugins/trpc.ts
@@ -63,7 +71,7 @@ export default defineNuxtPlugin(() => {
 });
 ```
 
-And call a procedure from a page:
+5. Create a page from this code. The page shows `Hello world`.
 
 ```vue
 <script setup lang="ts">
@@ -79,16 +87,16 @@ const { data } = await $trpc.greeting.useQuery(name);
 
 ## <a name="key-exports">🧩 Key Exports</a>
 
-| Export                                                       | Description                                                                                                     |
-| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
-| `createTRPCNuxtClient`                                       | The typed client, every procedure decorated with `useQuery`, `useLazyQuery`, `useMutation` or `useSubscription` |
-| `getMutationKey`, `getQueryKey`                              | The `useAsyncData` keys a procedure's data is cached under, for `useNuxtData` and `refreshNuxtData`             |
-| `httpBatchLink`, `httpLink`                                  | tRPC's links, sending through the request event during server rendering                                         |
-| `trpc-nuxt-module`                                           | The module — `router`, `createContext`, `endpoint` and `webSocket` options                                      |
-| `trpc-nuxt-module/runtime/server/createTRPCEventHandler`     | The HTTP handler over tRPC's fetch adapter, for a Nitro app without Nuxt                                        |
-| `trpc-nuxt-module/runtime/server/createTRPCWebSocketHandler` | The WebSocket handler over tRPC's `applyWSSHandler` and crossws, for a Nitro app without Nuxt                   |
+| Export                                                       | Description                                                                                                         |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------- |
+| `createTRPCNuxtClient`                                       | The typed client. Every procedure is decorated with `useQuery`, `useLazyQuery`, `useMutation` or `useSubscription`. |
+| `getMutationKey`, `getQueryKey`                              | The `useAsyncData` keys that cache a procedure's data. Used by `useNuxtData` and `refreshNuxtData`.                 |
+| `httpBatchLink`, `httpLink`                                  | tRPC's links. They send through the request event during server rendering.                                          |
+| `trpc-nuxt-module`                                           | The module. Its options are `router`, `createContext`, `endpoint` and `webSocket`.                                  |
+| `trpc-nuxt-module/runtime/server/createTRPCEventHandler`     | The HTTP handler over tRPC's fetch adapter. For a Nitro app without Nuxt.                                           |
+| `trpc-nuxt-module/runtime/server/createTRPCWebSocketHandler` | The WebSocket handler over tRPC's `applyWSSHandler` and crossws. For a Nitro app without Nuxt.                      |
 
-A WebSocket connection's open and close call the `trpc-nuxt-module:webSocket:open` and `trpc-nuxt-module:webSocket:close` Nitro runtime hooks with its context, typed off your router.
+A WebSocket connection calls the `trpc-nuxt-module:webSocket:open` Nitro runtime hook when it opens. It calls the `trpc-nuxt-module:webSocket:close` hook when it closes. Both hooks receive the connection's context, typed from your router.
 
 ## <a name="license">⚖️ License</a>
 

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { ModuleOptions } from "./models/ModuleOptions.js";
+import { NuxtModule } from "@nuxt/schema";
+declare module "@nuxt/schema" {
+  interface NuxtConfig {
+    trpc?: Partial<ModuleOptions>;
+  }
+}
+declare const trpcNuxtModule: NuxtModule<ModuleOptions>;
+export { type ModuleOptions, trpcNuxtModule as default };

package/dist/index.js

@@ -0,0 +1,84 @@
+import { DEFAULT_ENDPOINT, MODULE_NAME } from "./runtime/constants.js";
+import { getEventHandlerTemplate } from "./services/getEventHandlerTemplate.js";
+import { getWebSocketHandlerTemplate } from "./services/getWebSocketHandlerTemplate.js";
+import { getWebSocketHooksTypeTemplate } from "./services/getWebSocketHooksTypeTemplate.js";
+import { addImports, addServerHandler, addServerTemplate, addTypeTemplate, defineNuxtModule, resolvePath } from "@nuxt/kit";
+// src/module.ts
+const CLIENT_IMPORTS = [
+	{
+		from: "trpc-nuxt-module/runtime/client/createTRPCNuxtClient",
+		name: "createTRPCNuxtClient"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/getMutationKey",
+		name: "getMutationKey"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/getQueryKey",
+		name: "getQueryKey"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/httpBatchLink",
+		name: "httpBatchLink"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/httpLink",
+		name: "httpLink"
+	}
+];
+const EVENT_HANDLER_FILENAME = `#${MODULE_NAME}/eventHandler.mjs`;
+const WEBSOCKET_HANDLER_FILENAME = `#${MODULE_NAME}/webSocketHandler.mjs`;
+const trpcNuxtModule = defineNuxtModule({
+	defaults: { endpoint: DEFAULT_ENDPOINT },
+	meta: {
+		compatibility: { nuxt: ">=5.0.0-0" },
+		configKey: "trpc",
+		name: MODULE_NAME
+	},
+	async setup({ createContext, endpoint, router, webSocket }, nuxt) {
+		const resolvedRouter = {
+			...router,
+			from: await resolvePath(router.from)
+		};
+		const resolvedCreateContext = createContext && {
+			...createContext,
+			from: await resolvePath(createContext.from)
+		};
+		const routedEndpoint = `${nuxt.options.app.baseURL.replace(/\/$/u, "")}${endpoint}`;
+		addServerTemplate({
+			filename: EVENT_HANDLER_FILENAME,
+			getContents: () => getEventHandlerTemplate(resolvedRouter, routedEndpoint, resolvedCreateContext)
+		});
+		addServerHandler({
+			handler: EVENT_HANDLER_FILENAME,
+			route: `${endpoint}/**`
+		});
+		if (webSocket) {
+			nuxt.options.nitro.features = {
+				...nuxt.options.nitro.features,
+				websocket: true
+			};
+			addServerTemplate({
+				filename: WEBSOCKET_HANDLER_FILENAME,
+				getContents: () => getWebSocketHandlerTemplate(resolvedRouter, webSocket, resolvedCreateContext)
+			});
+			addServerHandler({
+				handler: WEBSOCKET_HANDLER_FILENAME,
+				lazy: true,
+				route: webSocket.endpoint
+			});
+			addTypeTemplate({
+				filename: `types/${MODULE_NAME}.d.ts`,
+				getContents: () => getWebSocketHooksTypeTemplate({
+					...resolvedRouter,
+					from: resolvedRouter.from.replace(/\.[cm]?ts$/u, "")
+				})
+			}, {
+				nitro: true,
+				nuxt: true
+			});
+		}
+		addImports([...CLIENT_IMPORTS]);
+	}
+});
+export { trpcNuxtModule as default };

package/dist/models/ExportReference.d.ts

@@ -0,0 +1,4 @@
+export interface ExportReference {
+  from: string;
+  name: string;
+}

package/dist/models/ModuleOptions.d.ts

@@ -0,0 +1,8 @@
+import { ExportReference } from "./ExportReference.js";
+import { WebSocketOptions } from "./WebSocketOptions.js";
+export interface ModuleOptions {
+  createContext?: ExportReference;
+  endpoint: string;
+  router: ExportReference;
+  webSocket?: WebSocketOptions;
+}

package/dist/models/TrpcServerFetch.d.ts

@@ -0,0 +1,2 @@
+import { serverFetch } from "nitro/app";
+export type TrpcServerFetch = typeof serverFetch;

package/dist/models/WebSocketOptions.d.ts

@@ -0,0 +1,6 @@
+import { AnyTRPCRouter } from "@trpc/server";
+import { WSSHandlerOptions } from "@trpc/server/adapters/ws";
+export interface WebSocketOptions {
+  endpoint: string;
+  keepAlive?: WSSHandlerOptions<AnyTRPCRouter>["keepAlive"];
+}

package/dist/runtime/client/createTRPCNuxtClient.d.ts

@@ -0,0 +1,4 @@
+import { TRPCNuxtClient } from "./models/TRPCNuxtClient.js";
+import { CreateTRPCClientOptions } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const createTRPCNuxtClient: <TRouter extends AnyTRPCRouter>(options: CreateTRPCClientOptions<TRouter>) => TRPCNuxtClient<TRouter>;

package/dist/runtime/client/createTRPCNuxtClient.js

@@ -0,0 +1,28 @@
+import { useProcedureMutation } from "./services/useProcedureMutation.js";
+import { useProcedureQuery } from "./services/useProcedureQuery.js";
+import { useProcedureSubscription } from "./services/useProcedureSubscription.js";
+import { createTRPCUntypedClient } from "@trpc/client";
+import { createTRPCRecursiveProxy } from "@trpc/server";
+// src/runtime/client/createTRPCNuxtClient.ts
+const createTRPCNuxtClient = (options) => {
+	const client = createTRPCUntypedClient(options);
+	return createTRPCRecursiveProxy(({ args: [first, second], path }) => {
+		const procedurePath = path.slice(0, -1);
+		const procedure = procedurePath.join(".");
+		switch (path.at(-1)) {
+			case "_def": return { path: procedurePath };
+			case "mutate": return client.mutation(procedure, first, second);
+			case "query": return client.query(procedure, first, second);
+			case "subscribe": return client.subscription(procedure, first, second);
+			case "useLazyQuery": return useProcedureQuery(client, procedure, first, {
+				...second,
+				lazy: true
+			});
+			case "useMutation": return useProcedureMutation(client, procedure, first);
+			case "useQuery": return useProcedureQuery(client, procedure, first, second);
+			case "useSubscription": return useProcedureSubscription(client, procedure, first, second);
+			default: throw new TypeError(`"${path.join(".")}" is not a procedure call`);
+		}
+	});
+};
+export { createTRPCNuxtClient };

package/dist/runtime/client/getMutationKey.d.ts

@@ -0,0 +1,2 @@
+import { ProcedureNode } from "./models/ProcedureNode.js";
+export declare const getMutationKey: (procedure: ProcedureNode) => string;

package/dist/runtime/client/getMutationKey.js

@@ -0,0 +1,4 @@
+import { getProcedureKey } from "./services/getProcedureKey.js";
+// src/runtime/client/getMutationKey.ts
+const getMutationKey = (procedure) => getProcedureKey(procedure._def().path.join("."));
+export { getMutationKey };

package/dist/runtime/client/getQueryKey.d.ts

@@ -0,0 +1,2 @@
+import { ProcedureNode } from "./models/ProcedureNode.js";
+export declare const getQueryKey: (procedure: ProcedureNode, input?: unknown) => string;

package/dist/runtime/client/getQueryKey.js

@@ -0,0 +1,4 @@
+import { getProcedureKey } from "./services/getProcedureKey.js";
+// src/runtime/client/getQueryKey.ts
+const getQueryKey = (procedure, input) => getProcedureKey(procedure._def().path.join("."), input);
+export { getQueryKey };

package/dist/runtime/client/httpBatchLink.d.ts

@@ -0,0 +1,3 @@
+import { HTTPBatchLinkOptions, TRPCLink } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const httpBatchLink: <TRouter extends AnyTRPCRouter>(options: HTTPBatchLinkOptions<TRouter["_def"]["_config"]["$types"]>) => TRPCLink<TRouter>;

package/dist/runtime/client/httpBatchLink.js

@@ -0,0 +1,8 @@
+import { getLinkFetch } from "./services/getLinkFetch.js";
+import { httpBatchLink as httpBatchLink$1 } from "@trpc/client";
+// src/runtime/client/httpBatchLink.ts
+const httpBatchLink = (options) => httpBatchLink$1({
+	fetch: getLinkFetch(),
+	...options
+});
+export { httpBatchLink };

package/dist/runtime/client/httpLink.d.ts

@@ -0,0 +1,3 @@
+import { HTTPLinkOptions, TRPCLink } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const httpLink: <TRouter extends AnyTRPCRouter>(options: HTTPLinkOptions<TRouter["_def"]["_config"]["$types"]>) => TRPCLink<TRouter>;

package/dist/runtime/client/httpLink.js

@@ -0,0 +1,8 @@
+import { getLinkFetch } from "./services/getLinkFetch.js";
+import { httpLink as httpLink$1 } from "@trpc/client";
+// src/runtime/client/httpLink.ts
+const httpLink = (options) => httpLink$1({
+	fetch: getLinkFetch(),
+	...options
+});
+export { httpLink };

package/dist/runtime/client/models/ConnectionStateSubscriptionStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum ConnectionStateSubscriptionStatus {
+  Connecting = "connecting",
+  Idle = "idle",
+  Pending = "pending"
+}

package/dist/runtime/client/models/ConnectionStateSubscriptionStatus.js

@@ -0,0 +1,8 @@
+// src/runtime/client/models/ConnectionStateSubscriptionStatus.ts
+let ConnectionStateSubscriptionStatus = /* @__PURE__ */ function(ConnectionStateSubscriptionStatus) {
+	ConnectionStateSubscriptionStatus["Connecting"] = "connecting";
+	ConnectionStateSubscriptionStatus["Idle"] = "idle";
+	ConnectionStateSubscriptionStatus["Pending"] = "pending";
+	return ConnectionStateSubscriptionStatus;
+}({});
+export { ConnectionStateSubscriptionStatus };

package/dist/runtime/client/models/DecoratedMutation.d.ts

@@ -0,0 +1,9 @@
+import { KeysOf } from "./KeysOf.js";
+import { ProcedureNode } from "./ProcedureNode.js";
+import { UseMutationOptions } from "./UseMutationOptions.js";
+import { UseMutationReturn } from "./UseMutationReturn.js";
+import { Resolver, TRPCResolverDef } from "@trpc/client";
+export interface DecoratedMutation<TDefinition extends TRPCResolverDef> extends ProcedureNode {
+  mutate: Resolver<TDefinition>;
+  useMutation: <TData = TDefinition["output"], TPickKeys extends KeysOf<TData> = KeysOf<TData>, TDefault = undefined>(options?: UseMutationOptions<TDefinition, TData, TPickKeys, TDefault>) => UseMutationReturn<TDefinition, TData, TPickKeys, TDefault>;
+}

package/dist/runtime/client/models/DecoratedMutation.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/DecoratedProcedure.d.ts

@@ -0,0 +1,6 @@
+import { DecoratedMutation } from "./DecoratedMutation.js";
+import { DecoratedQuery } from "./DecoratedQuery.js";
+import { DecoratedSubscription } from "./DecoratedSubscription.js";
+import { TRPCResolverDef } from "@trpc/client";
+import { TRPCProcedureType } from "@trpc/server";
+export type DecoratedProcedure<TType extends TRPCProcedureType, TDefinition extends TRPCResolverDef> = TType extends "query" ? DecoratedQuery<TDefinition> : TType extends "mutation" ? DecoratedMutation<TDefinition> : DecoratedSubscription<TDefinition>;

package/dist/runtime/client/models/DecoratedProcedure.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/DecoratedQuery.d.ts

@@ -0,0 +1,8 @@
+import { ProcedureNode } from "./ProcedureNode.js";
+import { UseQuery } from "./UseQuery.js";
+import { Resolver, TRPCResolverDef } from "@trpc/client";
+export interface DecoratedQuery<TDefinition extends TRPCResolverDef> extends ProcedureNode {
+  query: Resolver<TDefinition>;
+  useLazyQuery: UseQuery<TDefinition>;
+  useQuery: UseQuery<TDefinition>;
+}

package/dist/runtime/client/models/DecoratedQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/DecoratedRouterRecord.d.ts

@@ -0,0 +1,9 @@
+import { DecoratedProcedure } from "./DecoratedProcedure.js";
+import { ProcedureNode } from "./ProcedureNode.js";
+import { AnyTRPCProcedure, AnyTRPCRootTypes, TRPCRouterRecord, inferProcedureInput, inferTransformedProcedureOutput } from "@trpc/server";
+export type DecoratedRouterRecord<TRoot extends AnyTRPCRootTypes, TRecord extends TRPCRouterRecord> = ProcedureNode & { readonly [TKey in keyof TRecord]: TRecord[TKey] extends AnyTRPCProcedure ? DecoratedProcedure<TRecord[TKey]["_def"]["type"], {
+  errorShape: TRoot["errorShape"];
+  input: inferProcedureInput<TRecord[TKey]>;
+  output: inferTransformedProcedureOutput<TRoot, TRecord[TKey]>;
+  transformer: TRoot["transformer"];
+}> : TRecord[TKey] extends TRPCRouterRecord ? DecoratedRouterRecord<TRoot, TRecord[TKey]> : never; };

package/dist/runtime/client/models/DecoratedRouterRecord.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/DecoratedSubscription.d.ts

@@ -0,0 +1,8 @@
+import { UseSubscriptionOptions } from "./UseSubscriptionOptions.js";
+import { UseSubscriptionReturn } from "./UseSubscriptionReturn.js";
+import { MaybeRefOrGetter } from "vue";
+import { SubscriptionResolver, TRPCClientError, TRPCResolverDef } from "@trpc/client";
+export interface DecoratedSubscription<TDefinition extends TRPCResolverDef> {
+  subscribe: SubscriptionResolver<TDefinition>;
+  useSubscription: (input: MaybeRefOrGetter<TDefinition["input"]>, options?: UseSubscriptionOptions<TDefinition>) => UseSubscriptionReturn<Parameters<NonNullable<UseSubscriptionOptions<TDefinition>["onData"]>>[0], TRPCClientError<TDefinition>>;
+}

package/dist/runtime/client/models/DecoratedSubscription.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/KeysOf.d.ts

@@ -0,0 +1 @@
+export type KeysOf<T> = (T extends T ? (keyof T extends string ? keyof T : never) : never)[];

package/dist/runtime/client/models/KeysOf.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/PickFrom.d.ts

@@ -0,0 +1 @@
+export type PickFrom<T, TKeys extends string[]> = T extends unknown[] ? T : T extends Record<string, unknown> ? keyof T extends TKeys[number] ? T : TKeys[number] extends never ? T : Pick<T, TKeys[number]> : T;

package/dist/runtime/client/models/PickFrom.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/ProcedureNode.d.ts

@@ -0,0 +1,4 @@
+import { ProcedurePath } from "./ProcedurePath.js";
+export interface ProcedureNode {
+  readonly _def: () => ProcedurePath;
+}

package/dist/runtime/client/models/ProcedureNode.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/ProcedurePath.d.ts

@@ -0,0 +1,3 @@
+export interface ProcedurePath {
+  path: string[];
+}

package/dist/runtime/client/models/ProcedurePath.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/QueryAsyncData.d.ts

@@ -0,0 +1,6 @@
+import { KeysOf } from "./KeysOf.js";
+import { PickFrom } from "./PickFrom.js";
+import { QueryError } from "./QueryError.js";
+import { AsyncData } from "nuxt/app";
+import { TRPCResolverDef } from "@trpc/client";
+export type QueryAsyncData<TDefinition extends TRPCResolverDef, TData, TPickKeys extends KeysOf<TData>, TDefault> = AsyncData<PickFrom<TData, TPickKeys> | TDefault, QueryError<TDefinition> | undefined>;

package/dist/runtime/client/models/QueryAsyncData.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/QueryError.d.ts

@@ -0,0 +1,3 @@
+import { NuxtError } from "nuxt/app";
+import { TRPCClientErrorLike, TRPCResolverDef } from "@trpc/client";
+export type QueryError<TDefinition extends TRPCResolverDef> = NuxtError<TRPCClientErrorLike<TDefinition>["data"]>;

package/dist/runtime/client/models/QueryError.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/SubscriptionStatus.d.ts

@@ -0,0 +1,7 @@
+export declare const SubscriptionStatus: {
+  readonly Connecting: "connecting";
+  readonly Error: "error";
+  readonly Idle: "idle";
+  readonly Pending: "pending";
+};
+export type SubscriptionStatus = (typeof SubscriptionStatus)[keyof typeof SubscriptionStatus];

package/dist/runtime/client/models/SubscriptionStatus.js

@@ -0,0 +1,8 @@
+// src/runtime/client/models/SubscriptionStatus.ts
+const SubscriptionStatus = {
+	Connecting: "connecting",
+	Error: "error",
+	Idle: "idle",
+	Pending: "pending"
+};
+export { SubscriptionStatus };

package/dist/runtime/client/models/TRPCNuxtClient.d.ts

@@ -0,0 +1,3 @@
+import { DecoratedRouterRecord } from "./DecoratedRouterRecord.js";
+import { AnyTRPCRouter } from "@trpc/server";
+export type TRPCNuxtClient<TRouter extends AnyTRPCRouter> = DecoratedRouterRecord<TRouter["_def"]["_config"]["$types"], TRouter["_def"]["record"]>;

package/dist/runtime/client/models/TRPCNuxtClient.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseMutationOptions.d.ts

@@ -0,0 +1,8 @@
+import { KeysOf } from "./KeysOf.js";
+import { AsyncDataOptions } from "nuxt/app";
+import { TRPCRequestOptions, TRPCResolverDef } from "@trpc/client";
+import { Except } from "type-fest";
+export type UseMutationOptions<TDefinition extends TRPCResolverDef, TData = TDefinition["output"], TPickKeys extends KeysOf<TData> = KeysOf<TData>, TDefault = undefined> = Except<AsyncDataOptions<TDefinition["output"], TData, TPickKeys, TDefault>, "enabled" | "immediate" | "lazy" | "server" | "watch"> & {
+  mutationKey?: string;
+  trpc?: TRPCRequestOptions;
+};

package/dist/runtime/client/models/UseMutationOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseMutationReturn.d.ts

@@ -0,0 +1,7 @@
+import { KeysOf } from "./KeysOf.js";
+import { PickFrom } from "./PickFrom.js";
+import { QueryAsyncData } from "./QueryAsyncData.js";
+import { TRPCResolverDef } from "@trpc/client";
+export type UseMutationReturn<TDefinition extends TRPCResolverDef, TData, TPickKeys extends KeysOf<TData>, TDefault> = QueryAsyncData<TDefinition, TData, TPickKeys, TDefault> & {
+  mutate: (input: TDefinition["input"]) => Promise<PickFrom<TData, TPickKeys> | TDefault>;
+};

package/dist/runtime/client/models/UseMutationReturn.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseQuery.d.ts

@@ -0,0 +1,6 @@
+import { KeysOf } from "./KeysOf.js";
+import { QueryAsyncData } from "./QueryAsyncData.js";
+import { UseQueryOptions } from "./UseQueryOptions.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCResolverDef } from "@trpc/client";
+export type UseQuery<TDefinition extends TRPCResolverDef> = <TData = TDefinition["output"], TPickKeys extends KeysOf<TData> = KeysOf<TData>, TDefault = undefined>(input: MaybeRefOrGetter<TDefinition["input"]>, options?: UseQueryOptions<TDefinition, TData, TPickKeys, TDefault>) => QueryAsyncData<TDefinition, TData, TPickKeys, TDefault>;

package/dist/runtime/client/models/UseQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseQueryOptions.d.ts

@@ -0,0 +1,9 @@
+import { KeysOf } from "./KeysOf.js";
+import { AsyncDataOptions } from "nuxt/app";
+import { TRPCRequestOptions, TRPCResolverDef } from "@trpc/client";
+import { Except } from "type-fest";
+export type UseQueryOptions<TDefinition extends TRPCResolverDef, TData = TDefinition["output"], TPickKeys extends KeysOf<TData> = KeysOf<TData>, TDefault = undefined> = Except<AsyncDataOptions<TDefinition["output"], TData, TPickKeys, TDefault>, "watch"> & {
+  queryKey?: string;
+  trpc?: TRPCRequestOptions;
+  watch?: false | NonNullable<AsyncDataOptions<TDefinition["output"], TData, TPickKeys, TDefault>["watch"]>;
+};

package/dist/runtime/client/models/UseQueryOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseSubscriptionOptions.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from "vue";
+import { SubscriptionResolver, TRPCResolverDef } from "@trpc/client";
+export type UseSubscriptionOptions<TDefinition extends TRPCResolverDef> = Parameters<SubscriptionResolver<TDefinition>>[1] & {
+  enabled?: MaybeRefOrGetter<boolean>;
+};

package/dist/runtime/client/models/UseSubscriptionOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/models/UseSubscriptionReturn.d.ts

@@ -0,0 +1,8 @@
+import { SubscriptionStatus } from "./SubscriptionStatus.js";
+import { ShallowRef } from "vue";
+export interface UseSubscriptionReturn<TData, TError> {
+  data: ShallowRef<TData | undefined>;
+  error: ShallowRef<TError | undefined>;
+  reset: () => void;
+  status: ShallowRef<SubscriptionStatus>;
+}

package/dist/runtime/client/models/UseSubscriptionReturn.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/client/services/getLinkFetch.d.ts

@@ -0,0 +1,2 @@
+import { TRPCFetch } from "@trpc/client";
+export declare const getLinkFetch: () => TRPCFetch;

package/dist/runtime/client/services/getLinkFetch.js

@@ -0,0 +1,24 @@
+import { useTrpcServerFetch } from "./useTrpcServerFetch.js";
+import { useRequestEvent } from "nuxt/app";
+import { checkIsServer } from "@esposter/shared";
+import { fetchWithEvent, getProxyRequestHeaders } from "nitro/h3";
+// src/runtime/client/services/getLinkFetch.ts
+const getLinkFetch = () => {
+	if (checkIsServer()) {
+		const event = useRequestEvent();
+		if (event?.app) return (url, options) => fetchWithEvent(event, url, options);
+		if (event) {
+			const serverFetchInProcess = useTrpcServerFetch();
+			return (url, options) => {
+				const headers = new Headers(getProxyRequestHeaders(event, { host: true }));
+				for (const [name, value] of new Headers(options?.headers)) headers.set(name, value);
+				return serverFetchInProcess(new URL(url, event.url), {
+					...options,
+					headers
+				}, event.context);
+			};
+		}
+	}
+	return (input, init) => fetch(new URL(input, window.location.href), init);
+};
+export { getLinkFetch };

package/dist/runtime/client/services/getProcedureKey.d.ts

@@ -0,0 +1 @@
+export declare const getProcedureKey: (path: string, input?: unknown) => string;

package/dist/runtime/client/services/getProcedureKey.js

@@ -0,0 +1,4 @@
+import { hash } from "ohash";
+// src/runtime/client/services/getProcedureKey.ts
+const getProcedureKey = (path, input) => input === void 0 ? path : `${path}-${hash(input)}`;
+export { getProcedureKey };

package/dist/runtime/client/services/mergeSignals.d.ts

@@ -0,0 +1 @@
+export declare const mergeSignals: (signal: AbortSignal, callerSignal?: AbortSignal) => AbortSignal;

package/dist/runtime/client/services/mergeSignals.js

@@ -0,0 +1,3 @@
+// src/runtime/client/services/mergeSignals.ts
+const mergeSignals = (signal, callerSignal) => callerSignal ? AbortSignal.any([signal, callerSignal]) : signal;
+export { mergeSignals };

package/dist/runtime/client/services/useProcedureMutation.d.ts

@@ -0,0 +1,6 @@
+import { KeysOf } from "../models/KeysOf.js";
+import { UseMutationOptions } from "../models/UseMutationOptions.js";
+import { UseMutationReturn } from "../models/UseMutationReturn.js";
+import { TRPCResolverDef, TRPCUntypedClient } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const useProcedureMutation: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, { mutationKey, trpc, ...options }?: UseMutationOptions<TRPCResolverDef>) => UseMutationReturn<TRPCResolverDef, unknown, KeysOf<unknown>, undefined>;

package/dist/runtime/client/services/useProcedureMutation.js

@@ -0,0 +1,28 @@
+import { getProcedureKey } from "./getProcedureKey.js";
+import { createError, useAsyncData } from "nuxt/app";
+// src/runtime/client/services/useProcedureMutation.ts
+const useProcedureMutation = (client, path, { mutationKey = getProcedureKey(path), trpc, ...options } = {}) => {
+	let request = Promise.resolve();
+	const asyncData = useAsyncData(mutationKey, () => request, {
+		...options,
+		immediate: false,
+		server: false
+	});
+	return Object.assign(asyncData, { mutate: async (input) => {
+		const signals = [trpc?.signal, options.timeout === void 0 ? void 0 : AbortSignal.timeout(options.timeout)];
+		const ownRequest = client.mutation(path, input, {
+			...trpc,
+			signal: AbortSignal.any(signals.filter((signal) => signal !== void 0))
+		});
+		request = ownRequest;
+		await asyncData.execute();
+		const [outcome] = await Promise.allSettled([ownRequest]);
+		if (outcome.status === "rejected") throw createError(outcome.reason);
+		const transformed = options.transform ? await options.transform(outcome.value) : outcome.value;
+		if (!options.pick) return transformed;
+		const picked = {};
+		for (const key of options.pick) picked[key] = transformed[key];
+		return picked;
+	} });
+};
+export { useProcedureMutation };