trpc-nuxt-module 3.6.0

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

@@ -0,0 +1,8 @@
+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";
+//#region src/runtime/client/models/QueryAsyncData.d.ts
+export type QueryAsyncData<TDefinition extends TRPCResolverDef, TData, TPickKeys extends KeysOf<TData>, TDefault> = AsyncData<PickFrom<TData, TPickKeys> | TDefault, QueryError<TDefinition> | undefined>;
+//#endregion

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

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

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

@@ -0,0 +1,5 @@
+import { NuxtError } from "nuxt/app";
+import { TRPCClientErrorLike, TRPCResolverDef } from "@trpc/client";
+//#region src/runtime/client/models/QueryError.d.ts
+export type QueryError<TDefinition extends TRPCResolverDef> = NuxtError<TRPCClientErrorLike<TDefinition>["data"]>;
+//#endregion

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

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

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

@@ -0,0 +1,8 @@
+//#region src/runtime/client/models/SubscriptionStatus.d.ts
+export declare enum SubscriptionStatus {
+  Connecting = "connecting",
+  Error = "error",
+  Idle = "idle",
+  Pending = "pending"
+}
+//#endregion

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

@@ -0,0 +1,10 @@
+//#region src/runtime/client/models/SubscriptionStatus.ts
+let SubscriptionStatus = /* @__PURE__ */ function(SubscriptionStatus) {
+	SubscriptionStatus["Connecting"] = "connecting";
+	SubscriptionStatus["Error"] = "error";
+	SubscriptionStatus["Idle"] = "idle";
+	SubscriptionStatus["Pending"] = "pending";
+	return SubscriptionStatus;
+}({});
+//#endregion
+export { SubscriptionStatus };

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

@@ -0,0 +1,5 @@
+import { DecoratedRouterRecord } from "./DecoratedRouterRecord.js";
+import { AnyTRPCRouter } from "@trpc/server";
+//#region src/runtime/client/models/TRPCNuxtClient.d.ts
+export type TRPCNuxtClient<TRouter extends AnyTRPCRouter> = DecoratedRouterRecord<TRouter["_def"]["_config"]["$types"], TRouter["_def"]["record"]>;
+//#endregion

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

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

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

@@ -0,0 +1,10 @@
+import { KeysOf } from "./KeysOf.js";
+import { AsyncDataOptions } from "nuxt/app";
+import { TRPCRequestOptions, TRPCResolverDef } from "@trpc/client";
+import { Except } from "type-fest";
+//#region src/runtime/client/models/UseMutationOptions.d.ts
+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;
+};
+//#endregion

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

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

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

@@ -0,0 +1,9 @@
+import { KeysOf } from "./KeysOf.js";
+import { PickFrom } from "./PickFrom.js";
+import { QueryAsyncData } from "./QueryAsyncData.js";
+import { TRPCResolverDef } from "@trpc/client";
+//#region src/runtime/client/models/UseMutationReturn.d.ts
+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>;
+};
+//#endregion

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

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

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

@@ -0,0 +1,8 @@
+import { KeysOf } from "./KeysOf.js";
+import { QueryAsyncData } from "./QueryAsyncData.js";
+import { UseQueryOptions } from "./UseQueryOptions.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCResolverDef } from "@trpc/client";
+//#region src/runtime/client/models/UseQuery.d.ts
+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>;
+//#endregion

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

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

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

@@ -0,0 +1,11 @@
+import { KeysOf } from "./KeysOf.js";
+import { AsyncDataOptions } from "nuxt/app";
+import { TRPCRequestOptions, TRPCResolverDef } from "@trpc/client";
+import { Except } from "type-fest";
+//#region src/runtime/client/models/UseQueryOptions.d.ts
+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"]>;
+};
+//#endregion

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

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

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

@@ -0,0 +1,7 @@
+import { MaybeRefOrGetter } from "vue";
+import { SubscriptionResolver, TRPCResolverDef } from "@trpc/client";
+//#region src/runtime/client/models/UseSubscriptionOptions.d.ts
+export type UseSubscriptionOptions<TDefinition extends TRPCResolverDef> = Parameters<SubscriptionResolver<TDefinition>>[1] & {
+  enabled?: MaybeRefOrGetter<boolean>;
+};
+//#endregion

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

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

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

@@ -0,0 +1,10 @@
+import { SubscriptionStatus } from "./SubscriptionStatus.js";
+import { ShallowRef } from "vue";
+//#region src/runtime/client/models/UseSubscriptionReturn.d.ts
+export interface UseSubscriptionReturn<TData, TError> {
+  data: ShallowRef<TData | undefined>;
+  error: ShallowRef<TError | undefined>;
+  reset: () => void;
+  status: ShallowRef<SubscriptionStatus>;
+}
+//#endregion

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

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

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

@@ -0,0 +1,4 @@
+import { TRPCFetch } from "@trpc/client";
+//#region src/runtime/client/services/getLinkFetch.d.ts
+export declare const getLinkFetch: () => TRPCFetch;
+//#endregion

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

@@ -0,0 +1,12 @@
+import { useRequestEvent } from "nuxt/app";
+import { checkIsServer } from "@esposter/shared";
+//#region src/runtime/client/services/getLinkFetch.ts
+const getLinkFetch = () => {
+	if (checkIsServer()) {
+		const event = useRequestEvent();
+		if (event) return event.fetch;
+	}
+	return (input, init) => fetch(new URL(input, window.location.href), init);
+};
+//#endregion
+export { getLinkFetch };

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

@@ -0,0 +1,3 @@
+//#region src/runtime/client/services/getProcedureKey.d.ts
+export declare const getProcedureKey: (path: string, input?: unknown) => string;
+//#endregion

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

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

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

@@ -0,0 +1,3 @@
+//#region src/runtime/client/services/mergeSignals.d.ts
+export declare const mergeSignals: (signal: AbortSignal, callerSignal?: AbortSignal) => AbortSignal;
+//#endregion

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

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

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

@@ -0,0 +1,8 @@
+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";
+//#region src/runtime/client/services/useProcedureMutation.d.ts
+export declare const useProcedureMutation: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, { mutationKey, trpc, ...options }?: UseMutationOptions<TRPCResolverDef>) => UseMutationReturn<TRPCResolverDef, unknown, KeysOf<unknown>, undefined>;
+//#endregion

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

@@ -0,0 +1,23 @@
+import { getProcedureKey } from "./getProcedureKey.js";
+import { mergeSignals } from "./mergeSignals.js";
+import { useAsyncData } from "nuxt/app";
+//#region src/runtime/client/services/useProcedureMutation.ts
+const useProcedureMutation = (client, path, { mutationKey = getProcedureKey(path), trpc, ...options } = {}) => {
+	let mutationInput;
+	const asyncData = useAsyncData(mutationKey, (_nuxtApp, { signal }) => client.mutation(path, mutationInput, {
+		...trpc,
+		signal: mergeSignals(signal, trpc?.signal)
+	}), {
+		...options,
+		immediate: false,
+		server: false
+	});
+	return Object.assign(asyncData, { mutate: async (input) => {
+		mutationInput = input;
+		await asyncData.execute();
+		if (asyncData.error.value) throw asyncData.error.value;
+		return asyncData.data.value;
+	} });
+};
+//#endregion
+export { useProcedureMutation };

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

@@ -0,0 +1,9 @@
+import { KeysOf } from "../models/KeysOf.js";
+import { QueryAsyncData } from "../models/QueryAsyncData.js";
+import { UseQueryOptions } from "../models/UseQueryOptions.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCResolverDef, TRPCUntypedClient } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+//#region src/runtime/client/services/useProcedureQuery.d.ts
+export declare const useProcedureQuery: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, input: MaybeRefOrGetter<unknown>, { queryKey, trpc, watch, ...options }?: UseQueryOptions<TRPCResolverDef>) => QueryAsyncData<TRPCResolverDef, unknown, KeysOf<unknown>, undefined>;
+//#endregion

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

@@ -0,0 +1,14 @@
+import { getProcedureKey } from "./getProcedureKey.js";
+import { mergeSignals } from "./mergeSignals.js";
+import { useAsyncData } from "nuxt/app";
+import { toValue } from "vue";
+//#region src/runtime/client/services/useProcedureQuery.ts
+const useProcedureQuery = (client, path, input, { queryKey, trpc, watch, ...options } = {}) => useAsyncData(() => queryKey ?? getProcedureKey(path, toValue(input)), (_nuxtApp, { signal }) => client.query(path, toValue(input), {
+	...trpc,
+	signal: mergeSignals(signal, trpc?.signal)
+}), {
+	...options,
+	watch: watch === false ? void 0 : queryKey === void 0 ? watch : [...watch ?? [], () => toValue(input)]
+});
+//#endregion
+export { useProcedureQuery };

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

@@ -0,0 +1,8 @@
+import { UseSubscriptionOptions } from "../models/UseSubscriptionOptions.js";
+import { UseSubscriptionReturn } from "../models/UseSubscriptionReturn.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCClientError, TRPCResolverDef, TRPCUntypedClient } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+//#region src/runtime/client/services/useProcedureSubscription.d.ts
+export declare const useProcedureSubscription: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, input: MaybeRefOrGetter<unknown>, { enabled, ...options }?: UseSubscriptionOptions<TRPCResolverDef>) => UseSubscriptionReturn<unknown, TRPCClientError<AnyTRPCRouter>>;
+//#endregion

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

@@ -0,0 +1,66 @@
+import "../models/SubscriptionStatus.js";
+import { getCurrentScope, onScopeDispose, shallowRef, toValue, watch } from "vue";
+import { checkIsServer } from "@esposter/shared";
+//#region src/runtime/client/services/useProcedureSubscription.ts
+const ConnectionStateSubscriptionStatusMap = {
+	connecting: "connecting",
+	idle: "idle",
+	pending: "pending"
+};
+const useProcedureSubscription = (client, path, input, { enabled = true, ...options } = {}) => {
+	const data = shallowRef();
+	const error = shallowRef();
+	const status = shallowRef("idle");
+	let unsubscribable;
+	const unsubscribe = () => {
+		unsubscribable?.unsubscribe();
+		unsubscribable = void 0;
+		status.value = "idle";
+	};
+	const subscribe = () => {
+		unsubscribable?.unsubscribe();
+		error.value = void 0;
+		status.value = "connecting";
+		unsubscribable = client.subscription(path, toValue(input), {
+			...options,
+			onComplete: () => {
+				status.value = "idle";
+				options.onComplete?.();
+			},
+			onConnectionStateChange: (state) => {
+				status.value = state.error ? "error" : ConnectionStateSubscriptionStatusMap[state.state];
+				options.onConnectionStateChange?.(state);
+			},
+			onData: (value) => {
+				data.value = value;
+				options.onData?.(value);
+			},
+			onError: (newError) => {
+				error.value = newError;
+				status.value = "error";
+				options.onError?.(newError);
+			},
+			onStarted: (startedOptions) => {
+				status.value = "pending";
+				options.onStarted?.(startedOptions);
+			}
+		});
+	};
+	if (!checkIsServer()) watch([() => toValue(input), () => toValue(enabled)], ([, isEnabled]) => {
+		if (isEnabled) subscribe();
+		else unsubscribe();
+	}, { immediate: true });
+	if (getCurrentScope()) onScopeDispose(unsubscribe);
+	return {
+		data,
+		error,
+		reset: () => {
+			data.value = void 0;
+			unsubscribe();
+			if (toValue(enabled)) subscribe();
+		},
+		status
+	};
+};
+//#endregion
+export { useProcedureSubscription };

package/dist/runtime/constants.d.ts

@@ -0,0 +1,6 @@
+//#region src/runtime/constants.d.ts
+export declare const DEFAULT_ENDPOINT = "/api/trpc";
+export declare const MODULE_NAME = "trpc-nuxt-module";
+export declare const WEBSOCKET_CLOSE_HOOK: `${typeof MODULE_NAME}:webSocket:close`;
+export declare const WEBSOCKET_OPEN_HOOK: `${typeof MODULE_NAME}:webSocket:open`;
+//#endregion

package/dist/runtime/constants.js

@@ -0,0 +1,7 @@
+//#region src/runtime/constants.ts
+const DEFAULT_ENDPOINT = "/api/trpc";
+const MODULE_NAME = "trpc-nuxt-module";
+const WEBSOCKET_CLOSE_HOOK = `${MODULE_NAME}:webSocket:close`;
+const WEBSOCKET_OPEN_HOOK = `${MODULE_NAME}:webSocket:open`;
+//#endregion
+export { DEFAULT_ENDPOINT, MODULE_NAME, WEBSOCKET_CLOSE_HOOK, WEBSOCKET_OPEN_HOOK };

package/dist/runtime/server/createTRPCEventHandler.d.ts

@@ -0,0 +1,6 @@
+import { TRPCEventHandlerOptions } from "./models/TRPCEventHandlerOptions.js";
+import { AnyTRPCRouter } from "@trpc/server";
+import { EventHandler, EventHandlerRequest } from "h3";
+//#region src/runtime/server/createTRPCEventHandler.d.ts
+export declare const createTRPCEventHandler: <TRouter extends AnyTRPCRouter>({ createContext, endpoint, ...options }: TRPCEventHandlerOptions<TRouter>) => EventHandler<EventHandlerRequest, Promise<Response | undefined>>;
+//#endregion

package/dist/runtime/server/createTRPCEventHandler.js

@@ -0,0 +1,17 @@
+import { DEFAULT_ENDPOINT } from "../constants.js";
+import { toRequest } from "./services/toRequest.js";
+import { defineEventHandler } from "h3";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+//#region src/runtime/server/createTRPCEventHandler.ts
+const createTRPCEventHandler = ({ createContext, endpoint = DEFAULT_ENDPOINT, ...options }) => defineEventHandler(async (event) => {
+	const response = await fetchRequestHandler({
+		...options,
+		createContext: createContext && ((fetchCreateContextOptions) => createContext(event, fetchCreateContextOptions)),
+		endpoint,
+		req: await toRequest(event)
+	});
+	if (event.handled) return void 0;
+	return response;
+});
+//#endregion
+export { createTRPCEventHandler };

package/dist/runtime/server/createTRPCWebSocketHandler.d.ts

@@ -0,0 +1,6 @@
+import { TRPCWebSocketHandler } from "./models/TRPCWebSocketHandler.js";
+import { TRPCWebSocketHandlerOptions } from "./models/TRPCWebSocketHandlerOptions.js";
+import { AnyTRPCRouter } from "@trpc/server";
+//#region src/runtime/server/createTRPCWebSocketHandler.d.ts
+export declare const createTRPCWebSocketHandler: <TRouter extends AnyTRPCRouter>({ createContext, onClose, onOpen, ...options }: TRPCWebSocketHandlerOptions<TRouter>) => TRPCWebSocketHandler;
+//#endregion

package/dist/runtime/server/createTRPCWebSocketHandler.js

@@ -0,0 +1,63 @@
+import { PeerWebSocketAdapter } from "./models/PeerWebSocketAdapter.js";
+import { WebSocketServerAdapter } from "./models/WebSocketServerAdapter.js";
+import { toIncomingMessage } from "./services/toIncomingMessage.js";
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+//#region src/runtime/server/createTRPCWebSocketHandler.ts
+const createTRPCWebSocketHandler = ({ createContext, onClose, onOpen, ...options }) => {
+	const webSocketServer = new WebSocketServerAdapter();
+	const { broadcastReconnectNotification } = applyWSSHandler({
+		...options,
+		createContext,
+		wss: webSocketServer
+	});
+	const peerConnections = /* @__PURE__ */ new Map();
+	return {
+		broadcastReconnectNotification,
+		hooks: {
+			close: async (peer, { code, reason }) => {
+				const peerConnection = peerConnections.get(peer.id);
+				if (!peerConnection) return;
+				peerConnections.delete(peer.id);
+				peerConnection.client.receiveClose(code, reason);
+				await onClose?.({
+					context: await peerConnection.context,
+					peer
+				});
+			},
+			error: (peer, error) => {
+				peerConnections.get(peer.id)?.client.receiveError(error);
+			},
+			message: (peer, message) => {
+				peerConnections.get(peer.id)?.client.receiveMessage(message.text());
+			},
+			open: async (peer) => {
+				const client = new PeerWebSocketAdapter(peer);
+				const request = toIncomingMessage(peer);
+				const context = Promise.resolve(createContext({
+					info: {
+						accept: null,
+						calls: [],
+						connectionParams: null,
+						isBatchCall: false,
+						signal: new AbortController().signal,
+						type: "unknown",
+						url: new URL(peer.request.url)
+					},
+					req: request,
+					res: client
+				}));
+				peerConnections.set(peer.id, {
+					client,
+					context
+				});
+				webSocketServer.addConnection(client, request);
+				await onOpen?.({
+					context: await context,
+					peer
+				});
+			}
+		}
+	};
+};
+//#endregion
+export { createTRPCWebSocketHandler };

package/dist/runtime/server/models/PeerWebSocketAdapter.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from "node:events";
+import { Peer } from "crossws";
+//#region src/runtime/server/models/PeerWebSocketAdapter.d.ts
+export declare class PeerWebSocketAdapter extends EventEmitter {
+  #private;
+  readonly CLOSED: number;
+  readonly CLOSING: number;
+  readonly CONNECTING: number;
+  readonly OPEN: number;
+  readyState: number;
+  constructor(peer: Peer);
+  close(code?: number, reason?: string): void;
+  receiveClose(code?: number, reason?: string): void;
+  receiveError(error: unknown): void;
+  receiveMessage(message: string): void;
+  send(data: string): void;
+  terminate(): void;
+}
+//#endregion

package/dist/runtime/server/models/PeerWebSocketAdapter.js

@@ -0,0 +1,37 @@
+import { EventEmitter } from "node:events";
+//#region src/runtime/server/models/PeerWebSocketAdapter.ts
+var PeerWebSocketAdapter = class extends EventEmitter {
+	CLOSED = WebSocket.CLOSED;
+	CLOSING = WebSocket.CLOSING;
+	CONNECTING = WebSocket.CONNECTING;
+	OPEN = WebSocket.OPEN;
+	readyState = WebSocket.OPEN;
+	#peer;
+	constructor(peer) {
+		super();
+		this.#peer = peer;
+	}
+	close(code, reason) {
+		this.readyState = WebSocket.CLOSING;
+		this.#peer.close(code, reason);
+	}
+	receiveClose(code, reason) {
+		this.readyState = WebSocket.CLOSED;
+		this.emit("close", code, reason);
+	}
+	receiveError(error) {
+		this.emit("error", error);
+	}
+	receiveMessage(message) {
+		this.emit("message", Buffer.from(message), false);
+	}
+	send(data) {
+		this.#peer.send(data);
+	}
+	terminate() {
+		this.readyState = WebSocket.CLOSING;
+		this.#peer.terminate();
+	}
+};
+//#endregion
+export { PeerWebSocketAdapter };

package/dist/runtime/server/models/TRPCEventHandlerOptions.d.ts

@@ -0,0 +1,11 @@
+import { AnyTRPCRouter, inferRouterContext } from "@trpc/server";
+import { H3Event } from "h3";
+import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+import { Promisable } from "type-fest";
+import { HTTPBaseHandlerOptions } from "@trpc/server/http";
+//#region src/runtime/server/models/TRPCEventHandlerOptions.d.ts
+export type TRPCEventHandlerOptions<TRouter extends AnyTRPCRouter> = HTTPBaseHandlerOptions<TRouter, Request> & {
+  createContext?: (event: H3Event, options: FetchCreateContextFnOptions) => Promisable<inferRouterContext<TRouter>>;
+  endpoint?: string;
+};
+//#endregion

package/dist/runtime/server/models/TRPCEventHandlerOptions.js

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

package/dist/runtime/server/models/TRPCWebSocketConnection.d.ts

@@ -0,0 +1,7 @@
+import { Peer } from "crossws";
+//#region src/runtime/server/models/TRPCWebSocketConnection.d.ts
+export interface TRPCWebSocketConnection<TContext> {
+  context: TContext;
+  peer: Peer;
+}
+//#endregion

package/dist/runtime/server/models/TRPCWebSocketConnection.js

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

package/dist/runtime/server/models/TRPCWebSocketHandler.d.ts

@@ -0,0 +1,7 @@
+import { Hooks } from "crossws";
+//#region src/runtime/server/models/TRPCWebSocketHandler.d.ts
+export interface TRPCWebSocketHandler {
+  broadcastReconnectNotification: () => void;
+  hooks: Partial<Hooks>;
+}
+//#endregion

package/dist/runtime/server/models/TRPCWebSocketHandler.js

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

package/dist/runtime/server/models/TRPCWebSocketHandlerOptions.d.ts

@@ -0,0 +1,13 @@
+import { TRPCWebSocketConnection } from "./TRPCWebSocketConnection.js";
+import { AnyTRPCRouter, inferRouterContext } from "@trpc/server";
+import { IncomingMessage } from "node:http";
+import { CreateWSSContextFnOptions, WSSHandlerOptions } from "@trpc/server/adapters/ws";
+import { Promisable } from "type-fest";
+import { BaseHandlerOptions } from "@trpc/server/http";
+//#region src/runtime/server/models/TRPCWebSocketHandlerOptions.d.ts
+export type TRPCWebSocketHandlerOptions<TRouter extends AnyTRPCRouter> = BaseHandlerOptions<TRouter, IncomingMessage> & Pick<WSSHandlerOptions<TRouter>, "dangerouslyDisablePong" | "experimental_encoder" | "keepAlive" | "prefix"> & {
+  createContext: (options: CreateWSSContextFnOptions) => Promisable<inferRouterContext<TRouter>>;
+  onClose?: (connection: TRPCWebSocketConnection<inferRouterContext<TRouter>>) => Promisable<void>;
+  onOpen?: (connection: TRPCWebSocketConnection<inferRouterContext<TRouter>>) => Promisable<void>;
+};
+//#endregion

package/dist/runtime/server/models/TRPCWebSocketHandlerOptions.js

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

package/dist/runtime/server/models/WebSocketServerAdapter.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from "node:events";
+import { IncomingMessage } from "node:http";
+//#region src/runtime/server/models/WebSocketServerAdapter.d.ts
+export declare class WebSocketServerAdapter<TClient extends EventEmitter> extends EventEmitter {
+  readonly clients: Set<TClient>;
+  addConnection(client: TClient, request: IncomingMessage): void;
+}
+//#endregion

package/dist/runtime/server/models/WebSocketServerAdapter.js

@@ -0,0 +1,14 @@
+import { EventEmitter } from "node:events";
+//#region src/runtime/server/models/WebSocketServerAdapter.ts
+var WebSocketServerAdapter = class extends EventEmitter {
+	clients = /* @__PURE__ */ new Set();
+	addConnection(client, request) {
+		this.clients.add(client);
+		client.once("close", () => {
+			this.clients.delete(client);
+		});
+		this.emit("connection", client, request);
+	}
+};
+//#endregion
+export { WebSocketServerAdapter };

package/dist/runtime/server/services/getRequestSignal.d.ts

@@ -0,0 +1,4 @@
+import { H3Event } from "h3";
+//#region src/runtime/server/services/getRequestSignal.d.ts
+export declare const getRequestSignal: (event: H3Event) => AbortSignal;
+//#endregion

package/dist/runtime/server/services/getRequestSignal.js

@@ -0,0 +1,11 @@
+//#region src/runtime/server/services/getRequestSignal.ts
+const getRequestSignal = (event) => {
+	const abortController = new AbortController();
+	const { res } = event.node;
+	res.once("close", () => {
+		if (!res.writableFinished) abortController.abort();
+	});
+	return abortController.signal;
+};
+//#endregion
+export { getRequestSignal };

package/dist/runtime/server/services/toIncomingMessage.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage } from "node:http";
+import { Peer } from "crossws";
+//#region src/runtime/server/services/toIncomingMessage.d.ts
+export declare const toIncomingMessage: ({ request }: Peer) => IncomingMessage;
+//#endregion

package/dist/runtime/server/services/toIncomingMessage.js

@@ -0,0 +1,12 @@
+import { IncomingMessage } from "node:http";
+import { Socket } from "node:net";
+//#region src/runtime/server/services/toIncomingMessage.ts
+const toIncomingMessage = ({ request }) => {
+	const incomingMessage = new IncomingMessage(new Socket());
+	const { pathname, search } = new URL(request.url);
+	incomingMessage.url = `${pathname}${search}`;
+	incomingMessage.headers = Object.fromEntries(request.headers);
+	return incomingMessage;
+};
+//#endregion
+export { toIncomingMessage };

package/dist/runtime/server/services/toRequest.d.ts

@@ -0,0 +1,4 @@
+import { H3Event } from "h3";
+//#region src/runtime/server/services/toRequest.d.ts
+export declare const toRequest: (event: H3Event) => Promise<Request>;
+//#endregion