@trpc/client 11.1.2 → 11.1.3-alpha-tmp-tsdown.23

package/dist/links/wsLink/wsClient/wsConnection.mjs

@@ -1,185 +1,164 @@
-import { behaviorSubject } from '@trpc/server/observable';
-import { prepareUrl, buildConnectionMessage, withResolvers } from './utils.mjs';
+import { buildConnectionMessage, prepareUrl, withResolvers } from "./utils.mjs";
+import { behaviorSubject } from "@trpc/server/observable";
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
+//#region src/links/wsLink/wsClient/wsConnection.ts
 /**
- * Opens a WebSocket connection asynchronously and returns a promise
- * that resolves when the connection is successfully established.
- * The promise rejects if an error occurs during the connection attempt.
- */ function asyncWsOpen(ws) {
-    const { promise, resolve, reject } = withResolvers();
-    ws.addEventListener('open', ()=>{
-        ws.removeEventListener('error', reject);
-        resolve();
-    });
-    ws.addEventListener('error', reject);
-    return promise;
+* Opens a WebSocket connection asynchronously and returns a promise
+* that resolves when the connection is successfully established.
+* The promise rejects if an error occurs during the connection attempt.
+*/
+function asyncWsOpen(ws) {
+	const { promise, resolve, reject } = withResolvers();
+	ws.addEventListener("open", () => {
+		ws.removeEventListener("error", reject);
+		resolve();
+	});
+	ws.addEventListener("error", reject);
+	return promise;
 }
 /**
- * Sets up a periodic ping-pong mechanism to keep the WebSocket connection alive.
- *
- * - Sends "PING" messages at regular intervals defined by `intervalMs`.
- * - If a "PONG" response is not received within the `pongTimeoutMs`, the WebSocket is closed.
- * - The ping timer resets upon receiving any message to maintain activity.
- * - Automatically starts the ping process when the WebSocket connection is opened.
- * - Cleans up timers when the WebSocket is closed.
- *
- * @param ws - The WebSocket instance to manage.
- * @param options - Configuration options for ping-pong intervals and timeouts.
- */ function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
-    let pingTimeout;
-    let pongTimeout;
-    function start() {
-        pingTimeout = setTimeout(()=>{
-            ws.send('PING');
-            pongTimeout = setTimeout(()=>{
-                ws.close();
-            }, pongTimeoutMs);
-        }, intervalMs);
-    }
-    function reset() {
-        clearTimeout(pingTimeout);
-        start();
-    }
-    function pong() {
-        clearTimeout(pongTimeout);
-        reset();
-    }
-    ws.addEventListener('open', start);
-    ws.addEventListener('message', ({ data })=>{
-        clearTimeout(pingTimeout);
-        start();
-        if (data === 'PONG') {
-            pong();
-        }
-    });
-    ws.addEventListener('close', ()=>{
-        clearTimeout(pingTimeout);
-        clearTimeout(pongTimeout);
-    });
+* Sets up a periodic ping-pong mechanism to keep the WebSocket connection alive.
+*
+* - Sends "PING" messages at regular intervals defined by `intervalMs`.
+* - If a "PONG" response is not received within the `pongTimeoutMs`, the WebSocket is closed.
+* - The ping timer resets upon receiving any message to maintain activity.
+* - Automatically starts the ping process when the WebSocket connection is opened.
+* - Cleans up timers when the WebSocket is closed.
+*
+* @param ws - The WebSocket instance to manage.
+* @param options - Configuration options for ping-pong intervals and timeouts.
+*/
+function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
+	let pingTimeout;
+	let pongTimeout;
+	function start() {
+		pingTimeout = setTimeout(() => {
+			ws.send("PING");
+			pongTimeout = setTimeout(() => {
+				ws.close();
+			}, pongTimeoutMs);
+		}, intervalMs);
+	}
+	function reset() {
+		clearTimeout(pingTimeout);
+		start();
+	}
+	function pong() {
+		clearTimeout(pongTimeout);
+		reset();
+	}
+	ws.addEventListener("open", start);
+	ws.addEventListener("message", ({ data }) => {
+		clearTimeout(pingTimeout);
+		start();
+		if (data === "PONG") pong();
+	});
+	ws.addEventListener("close", () => {
+		clearTimeout(pingTimeout);
+		clearTimeout(pongTimeout);
+	});
 }
 /**
- * Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,
- * and observable state tracking.
- */ class WsConnection {
-    get ws() {
-        return this.wsObservable.get();
-    }
-    set ws(ws) {
-        this.wsObservable.next(ws);
-    }
-    /**
-   * Checks if the WebSocket connection is open and ready to communicate.
-   */ isOpen() {
-        return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
-    }
-    /**
-   * Checks if the WebSocket connection is closed or in the process of closing.
-   */ isClosed() {
-        return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
-    }
-    async open() {
-        if (this.openPromise) return this.openPromise;
-        this.id = ++WsConnection.connectCount;
-        const wsPromise = prepareUrl(this.urlOptions).then((url)=>new this.WebSocketPonyfill(url));
-        this.openPromise = wsPromise.then(async (ws)=>{
-            this.ws = ws;
-            // Setup ping listener
-            ws.addEventListener('message', function({ data }) {
-                if (data === 'PING') {
-                    this.send('PONG');
-                }
-            });
-            if (this.keepAliveOpts.enabled) {
-                setupPingInterval(ws, this.keepAliveOpts);
-            }
-            ws.addEventListener('close', ()=>{
-                if (this.ws === ws) {
-                    this.ws = null;
-                }
-            });
-            await asyncWsOpen(ws);
-            if (this.urlOptions.connectionParams) {
-                ws.send(await buildConnectionMessage(this.urlOptions.connectionParams));
-            }
-        });
-        try {
-            await this.openPromise;
-        } finally{
-            this.openPromise = null;
-        }
-    }
-    /**
-   * Closes the WebSocket connection gracefully.
-   * Waits for any ongoing open operation to complete before closing.
-   */ async close() {
-        try {
-            await this.openPromise;
-        } finally{
-            this.ws?.close();
-        }
-    }
-    constructor(opts){
-        _define_property(this, "id", ++WsConnection.connectCount);
-        _define_property(this, "WebSocketPonyfill", void 0);
-        _define_property(this, "urlOptions", void 0);
-        _define_property(this, "keepAliveOpts", void 0);
-        _define_property(this, "wsObservable", behaviorSubject(null));
-        /**
-   * Manages the WebSocket opening process, ensuring that only one open operation
-   * occurs at a time. Tracks the ongoing operation with `openPromise` to avoid
-   * redundant calls and ensure proper synchronization.
-   *
-   * Sets up the keep-alive mechanism and necessary event listeners for the connection.
-   *
-   * @returns A promise that resolves once the WebSocket connection is successfully opened.
-   */ _define_property(this, "openPromise", null);
-        this.WebSocketPonyfill = opts.WebSocketPonyfill ?? WebSocket;
-        if (!this.WebSocketPonyfill) {
-            throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
-        }
-        this.urlOptions = opts.urlOptions;
-        this.keepAliveOpts = opts.keepAlive;
-    }
-}
-_define_property(WsConnection, "connectCount", 0);
+* Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,
+* and observable state tracking.
+*/
+var WsConnection = class WsConnection {
+	static connectCount = 0;
+	id = ++WsConnection.connectCount;
+	WebSocketPonyfill;
+	urlOptions;
+	keepAliveOpts;
+	wsObservable = behaviorSubject(null);
+	constructor(opts) {
+		this.WebSocketPonyfill = opts.WebSocketPonyfill ?? WebSocket;
+		if (!this.WebSocketPonyfill) throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+		this.urlOptions = opts.urlOptions;
+		this.keepAliveOpts = opts.keepAlive;
+	}
+	get ws() {
+		return this.wsObservable.get();
+	}
+	set ws(ws) {
+		this.wsObservable.next(ws);
+	}
+	/**
+	* Checks if the WebSocket connection is open and ready to communicate.
+	*/
+	isOpen() {
+		return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+	}
+	/**
+	* Checks if the WebSocket connection is closed or in the process of closing.
+	*/
+	isClosed() {
+		return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
+	}
+	/**
+	* Manages the WebSocket opening process, ensuring that only one open operation
+	* occurs at a time. Tracks the ongoing operation with `openPromise` to avoid
+	* redundant calls and ensure proper synchronization.
+	*
+	* Sets up the keep-alive mechanism and necessary event listeners for the connection.
+	*
+	* @returns A promise that resolves once the WebSocket connection is successfully opened.
+	*/
+	openPromise = null;
+	async open() {
+		if (this.openPromise) return this.openPromise;
+		this.id = ++WsConnection.connectCount;
+		const wsPromise = prepareUrl(this.urlOptions).then((url) => new this.WebSocketPonyfill(url));
+		this.openPromise = wsPromise.then(async (ws) => {
+			this.ws = ws;
+			ws.addEventListener("message", function({ data }) {
+				if (data === "PING") this.send("PONG");
+			});
+			if (this.keepAliveOpts.enabled) setupPingInterval(ws, this.keepAliveOpts);
+			ws.addEventListener("close", () => {
+				if (this.ws === ws) this.ws = null;
+			});
+			await asyncWsOpen(ws);
+			if (this.urlOptions.connectionParams) ws.send(await buildConnectionMessage(this.urlOptions.connectionParams));
+		});
+		try {
+			await this.openPromise;
+		} finally {
+			this.openPromise = null;
+		}
+	}
+	/**
+	* Closes the WebSocket connection gracefully.
+	* Waits for any ongoing open operation to complete before closing.
+	*/
+	async close() {
+		try {
+			await this.openPromise;
+		} finally {
+			this.ws?.close();
+		}
+	}
+};
 /**
- * Provides a backward-compatible representation of the connection state.
- */ function backwardCompatibility(connection) {
-    if (connection.isOpen()) {
-        return {
-            id: connection.id,
-            state: 'open',
-            ws: connection.ws
-        };
-    }
-    if (connection.isClosed()) {
-        return {
-            id: connection.id,
-            state: 'closed',
-            ws: connection.ws
-        };
-    }
-    if (!connection.ws) {
-        return null;
-    }
-    return {
-        id: connection.id,
-        state: 'connecting',
-        ws: connection.ws
-    };
+* Provides a backward-compatible representation of the connection state.
+*/
+function backwardCompatibility(connection) {
+	if (connection.isOpen()) return {
+		id: connection.id,
+		state: "open",
+		ws: connection.ws
+	};
+	if (connection.isClosed()) return {
+		id: connection.id,
+		state: "closed",
+		ws: connection.ws
+	};
+	if (!connection.ws) return null;
+	return {
+		id: connection.id,
+		state: "connecting",
+		ws: connection.ws
+	};
 }
 
+//#endregion
 export { WsConnection, backwardCompatibility };
+//# sourceMappingURL=wsConnection.mjs.map

package/dist/links/wsLink/wsClient/wsConnection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnection.mjs","names":["ws: WebSocket","pingTimeout: ReturnType<typeof setTimeout> | undefined","pongTimeout: ReturnType<typeof setTimeout> | undefined","opts: WebSocketConnectionOptions","connection: WsConnection"],"sources":["../../../../src/links/wsLink/wsClient/wsConnection.ts"],"sourcesContent":["import { behaviorSubject } from '@trpc/server/observable';\nimport type { UrlOptionsWithConnectionParams } from '../../internals/urlWithConnectionParams';\nimport { buildConnectionMessage, prepareUrl, withResolvers } from './utils';\n\n/**\n * Opens a WebSocket connection asynchronously and returns a promise\n * that resolves when the connection is successfully established.\n * The promise rejects if an error occurs during the connection attempt.\n */\nfunction asyncWsOpen(ws: WebSocket) {\n  const { promise, resolve, reject } = withResolvers<void>();\n\n  ws.addEventListener('open', () => {\n    ws.removeEventListener('error', reject);\n    resolve();\n  });\n  ws.addEventListener('error', reject);\n\n  return promise;\n}\n\ninterface PingPongOptions {\n  /**\n   * The interval (in milliseconds) between \"PING\" messages.\n   */\n  intervalMs: number;\n\n  /**\n   * The timeout (in milliseconds) to wait for a \"PONG\" response before closing the connection.\n   */\n  pongTimeoutMs: number;\n}\n\n/**\n * Sets up a periodic ping-pong mechanism to keep the WebSocket connection alive.\n *\n * - Sends \"PING\" messages at regular intervals defined by `intervalMs`.\n * - If a \"PONG\" response is not received within the `pongTimeoutMs`, the WebSocket is closed.\n * - The ping timer resets upon receiving any message to maintain activity.\n * - Automatically starts the ping process when the WebSocket connection is opened.\n * - Cleans up timers when the WebSocket is closed.\n *\n * @param ws - The WebSocket instance to manage.\n * @param options - Configuration options for ping-pong intervals and timeouts.\n */\nfunction setupPingInterval(\n  ws: WebSocket,\n  { intervalMs, pongTimeoutMs }: PingPongOptions,\n) {\n  let pingTimeout: ReturnType<typeof setTimeout> | undefined;\n  let pongTimeout: ReturnType<typeof setTimeout> | undefined;\n\n  function start() {\n    pingTimeout = setTimeout(() => {\n      ws.send('PING');\n      pongTimeout = setTimeout(() => {\n        ws.close();\n      }, pongTimeoutMs);\n    }, intervalMs);\n  }\n\n  function reset() {\n    clearTimeout(pingTimeout);\n    start();\n  }\n\n  function pong() {\n    clearTimeout(pongTimeout);\n    reset();\n  }\n\n  ws.addEventListener('open', start);\n  ws.addEventListener('message', ({ data }) => {\n    clearTimeout(pingTimeout);\n    start();\n\n    if (data === 'PONG') {\n      pong();\n    }\n  });\n  ws.addEventListener('close', () => {\n    clearTimeout(pingTimeout);\n    clearTimeout(pongTimeout);\n  });\n}\n\nexport interface WebSocketConnectionOptions {\n  WebSocketPonyfill?: typeof WebSocket;\n  urlOptions: UrlOptionsWithConnectionParams;\n  keepAlive: PingPongOptions & {\n    enabled: boolean;\n  };\n}\n\n/**\n * Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,\n * and observable state tracking.\n */\nexport class WsConnection {\n  static connectCount = 0;\n  public id = ++WsConnection.connectCount;\n\n  private readonly WebSocketPonyfill: typeof WebSocket;\n  private readonly urlOptions: UrlOptionsWithConnectionParams;\n  private readonly keepAliveOpts: WebSocketConnectionOptions['keepAlive'];\n  public readonly wsObservable = behaviorSubject<WebSocket | null>(null);\n\n  constructor(opts: WebSocketConnectionOptions) {\n    this.WebSocketPonyfill = opts.WebSocketPonyfill ?? WebSocket;\n    if (!this.WebSocketPonyfill) {\n      throw new Error(\n        \"No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill\",\n      );\n    }\n\n    this.urlOptions = opts.urlOptions;\n    this.keepAliveOpts = opts.keepAlive;\n  }\n\n  public get ws() {\n    return this.wsObservable.get();\n  }\n\n  private set ws(ws) {\n    this.wsObservable.next(ws);\n  }\n\n  /**\n   * Checks if the WebSocket connection is open and ready to communicate.\n   */\n  public isOpen(): this is { ws: WebSocket } {\n    return (\n      !!this.ws &&\n      this.ws.readyState === this.WebSocketPonyfill.OPEN &&\n      !this.openPromise\n    );\n  }\n\n  /**\n   * Checks if the WebSocket connection is closed or in the process of closing.\n   */\n  public isClosed(): this is { ws: WebSocket } {\n    return (\n      !!this.ws &&\n      (this.ws.readyState === this.WebSocketPonyfill.CLOSING ||\n        this.ws.readyState === this.WebSocketPonyfill.CLOSED)\n    );\n  }\n\n  /**\n   * Manages the WebSocket opening process, ensuring that only one open operation\n   * occurs at a time. Tracks the ongoing operation with `openPromise` to avoid\n   * redundant calls and ensure proper synchronization.\n   *\n   * Sets up the keep-alive mechanism and necessary event listeners for the connection.\n   *\n   * @returns A promise that resolves once the WebSocket connection is successfully opened.\n   */\n  private openPromise: Promise<void> | null = null;\n  public async open() {\n    if (this.openPromise) return this.openPromise;\n\n    this.id = ++WsConnection.connectCount;\n    const wsPromise = prepareUrl(this.urlOptions).then(\n      (url) => new this.WebSocketPonyfill(url),\n    );\n    this.openPromise = wsPromise.then(async (ws) => {\n      this.ws = ws;\n\n      // Setup ping listener\n      ws.addEventListener('message', function ({ data }) {\n        if (data === 'PING') {\n          this.send('PONG');\n        }\n      });\n\n      if (this.keepAliveOpts.enabled) {\n        setupPingInterval(ws, this.keepAliveOpts);\n      }\n\n      ws.addEventListener('close', () => {\n        if (this.ws === ws) {\n          this.ws = null;\n        }\n      });\n\n      await asyncWsOpen(ws);\n\n      if (this.urlOptions.connectionParams) {\n        ws.send(await buildConnectionMessage(this.urlOptions.connectionParams));\n      }\n    });\n\n    try {\n      await this.openPromise;\n    } finally {\n      this.openPromise = null;\n    }\n  }\n\n  /**\n   * Closes the WebSocket connection gracefully.\n   * Waits for any ongoing open operation to complete before closing.\n   */\n  public async close() {\n    try {\n      await this.openPromise;\n    } finally {\n      this.ws?.close();\n    }\n  }\n}\n\n/**\n * Provides a backward-compatible representation of the connection state.\n */\nexport function backwardCompatibility(connection: WsConnection) {\n  if (connection.isOpen()) {\n    return {\n      id: connection.id,\n      state: 'open',\n      ws: connection.ws,\n    } as const;\n  }\n\n  if (connection.isClosed()) {\n    return {\n      id: connection.id,\n      state: 'closed',\n      ws: connection.ws,\n    } as const;\n  }\n\n  if (!connection.ws) {\n    return null;\n  }\n\n  return {\n    id: connection.id,\n    state: 'connecting',\n    ws: connection.ws,\n  } as const;\n}\n"],"mappings":"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"}

package/dist/links/wsLink/wsLink.d.mts

@@ -0,0 +1,15 @@
+import { TRPCLink } from "../types.mjs";
+import { TransformerOptions } from "../../internals/transformer.mjs";
+import { WebSocketClientOptions } from "./wsClient/options.mjs";
+import { TRPCWebSocketClient, createWSClient$1 as createWSClient } from "./createWsClient.mjs";
+import { AnyRouter, inferClientTypes } from "@trpc/server/unstable-core-do-not-import";
+
+//#region src/links/wsLink/wsLink.d.ts
+type WebSocketLinkOptions<TRouter extends AnyRouter> = {
+  client: TRPCWebSocketClient;
+} & TransformerOptions<inferClientTypes<TRouter>>;
+declare function wsLink<TRouter extends AnyRouter>(opts: WebSocketLinkOptions<TRouter>): TRPCLink<TRouter>;
+
+//#endregion
+export { TRPCWebSocketClient, WebSocketClientOptions, WebSocketLinkOptions, createWSClient, wsLink };
+//# sourceMappingURL=wsLink.d.mts.map

package/dist/links/wsLink/wsLink.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsLink.d.mts","names":[],"sources":["../../../src/links/wsLink/wsLink.ts"],"sourcesContent":[],"mappings":";;;;;;;KAcY,qCAAqC;UACvC;AADV,CAAA,GAEI,kBAFQ,CAEW,gBAFS,CAEQ,OAFR,CAAA,CAAA;AAAA,iBAIhB,MAJgB,CAAA,gBAIO,SAJP,CAAA,CAAA,IAAA,EAKxB,oBALwB,CAKH,OALG,CAAA,CAAA,EAM7B,QAN6B,CAMpB,OANoB,CAAA"}

package/dist/links/wsLink/wsLink.d.ts

@@ -1,11 +1,15 @@
-import type { AnyRouter, inferClientTypes } from '@trpc/server/unstable-core-do-not-import';
-import type { TransformerOptions } from '../../unstable-internals';
-import type { TRPCLink } from '../types';
-import type { TRPCWebSocketClient, WebSocketClientOptions } from './createWsClient';
-import { createWSClient } from './createWsClient';
-export type WebSocketLinkOptions<TRouter extends AnyRouter> = {
-    client: TRPCWebSocketClient;
+import { TRPCLink } from "../types.js";
+import { TransformerOptions } from "../../internals/transformer.js";
+import { WebSocketClientOptions } from "./wsClient/options.js";
+import { TRPCWebSocketClient, createWSClient } from "./createWsClient.js";
+import { AnyRouter, inferClientTypes } from "@trpc/server/unstable-core-do-not-import";
+
+//#region src/links/wsLink/wsLink.d.ts
+type WebSocketLinkOptions<TRouter extends AnyRouter> = {
+  client: TRPCWebSocketClient;
 } & TransformerOptions<inferClientTypes<TRouter>>;
-export declare function wsLink<TRouter extends AnyRouter>(opts: WebSocketLinkOptions<TRouter>): TRPCLink<TRouter>;
-export { TRPCWebSocketClient, WebSocketClientOptions, createWSClient };
+declare function wsLink<TRouter extends AnyRouter>(opts: WebSocketLinkOptions<TRouter>): TRPCLink<TRouter>;
+
+//#endregion
+export { TRPCWebSocketClient, WebSocketClientOptions, WebSocketLinkOptions, createWSClient, wsLink };
 //# sourceMappingURL=wsLink.d.ts.map

package/dist/links/wsLink/wsLink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wsLink.d.ts","sourceRoot":"","sources":["../../../src/links/wsLink/wsLink.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,MAAM,oBAAoB,CAAC,OAAO,SAAS,SAAS,IAAI;IAC5D,MAAM,EAAE,mBAAmB,CAAC;CAC7B,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAElD,wBAAgB,MAAM,CAAC,OAAO,SAAS,SAAS,EAC9C,IAAI,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAClC,QAAQ,CAAC,OAAO,CAAC,CAgCnB;AAED,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"wsLink.d.ts","names":[],"sources":["../../../src/links/wsLink/wsLink.ts"],"sourcesContent":[],"mappings":";;;;;;;KAcY,qCAAqC;UACvC;AADV,CAAA,GAEI,kBAFQ,CAEW,gBAFS,CAEQ,OAFR,CAAA,CAAA;AAAA,iBAIhB,MAJgB,CAAA,gBAIO,SAJP,CAAA,CAAA,IAAA,EAKxB,oBALwB,CAKH,OALG,CAAA,CAAA,EAM7B,QAN6B,CAMpB,OANoB,CAAA"}

package/dist/links/wsLink/wsLink.js

@@ -1,35 +1,34 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var transformer = require('../../internals/transformer.js');
-var createWsClient = require('./createWsClient.js');
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require__Users_julius_dev_trpc_packages_client_src_internals_transformer = require('../../internals/transformer.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_wsLink_createWsClient = require('./createWsClient.js');
+const __trpc_server_observable = require_rolldown_runtime.__toESM(require("@trpc/server/observable"));
 
+//#region src/links/wsLink/wsLink.ts
 function wsLink(opts) {
-    const { client } = opts;
-    const transformer$1 = transformer.getTransformer(opts.transformer);
-    return ()=>{
-        return ({ op })=>{
-            return observable.observable((observer)=>{
-                const connStateSubscription = op.type === 'subscription' ? client.connectionState.subscribe({
-                    next (result) {
-                        observer.next({
-                            result,
-                            context: op.context
-                        });
-                    }
-                }) : null;
-                const requestSubscription = client.request({
-                    op,
-                    transformer: transformer$1
-                }).subscribe(observer);
-                return ()=>{
-                    requestSubscription.unsubscribe();
-                    connStateSubscription?.unsubscribe();
-                };
-            });
-        };
-    };
+	const { client } = opts;
+	const transformer = require__Users_julius_dev_trpc_packages_client_src_internals_transformer.getTransformer(opts.transformer);
+	return () => {
+		return ({ op }) => {
+			return (0, __trpc_server_observable.observable)((observer) => {
+				const connStateSubscription = op.type === "subscription" ? client.connectionState.subscribe({ next(result) {
+					observer.next({
+						result,
+						context: op.context
+					});
+				} }) : null;
+				const requestSubscription = client.request({
+					op,
+					transformer
+				}).subscribe(observer);
+				return () => {
+					requestSubscription.unsubscribe();
+					connStateSubscription?.unsubscribe();
+				};
+			});
+		};
+	};
 }
 
-exports.createWSClient = createWsClient.createWSClient;
-exports.wsLink = wsLink;
+//#endregion
+exports.createWSClient = require__Users_julius_dev_trpc_packages_client_src_links_wsLink_createWsClient.createWSClient;
+exports.wsLink = wsLink;

package/dist/links/wsLink/wsLink.mjs

@@ -1,32 +1,33 @@
-import { observable } from '@trpc/server/observable';
-import { getTransformer } from '../../internals/transformer.mjs';
-export { createWSClient } from './createWsClient.mjs';
+import { getTransformer } from "../../internals/transformer.mjs";
+import { createWSClient } from "./createWsClient.mjs";
+import { observable } from "@trpc/server/observable";
 
+//#region src/links/wsLink/wsLink.ts
 function wsLink(opts) {
-    const { client } = opts;
-    const transformer = getTransformer(opts.transformer);
-    return ()=>{
-        return ({ op })=>{
-            return observable((observer)=>{
-                const connStateSubscription = op.type === 'subscription' ? client.connectionState.subscribe({
-                    next (result) {
-                        observer.next({
-                            result,
-                            context: op.context
-                        });
-                    }
-                }) : null;
-                const requestSubscription = client.request({
-                    op,
-                    transformer
-                }).subscribe(observer);
-                return ()=>{
-                    requestSubscription.unsubscribe();
-                    connStateSubscription?.unsubscribe();
-                };
-            });
-        };
-    };
+	const { client } = opts;
+	const transformer = getTransformer(opts.transformer);
+	return () => {
+		return ({ op }) => {
+			return observable((observer) => {
+				const connStateSubscription = op.type === "subscription" ? client.connectionState.subscribe({ next(result) {
+					observer.next({
+						result,
+						context: op.context
+					});
+				} }) : null;
+				const requestSubscription = client.request({
+					op,
+					transformer
+				}).subscribe(observer);
+				return () => {
+					requestSubscription.unsubscribe();
+					connStateSubscription?.unsubscribe();
+				};
+			});
+		};
+	};
 }
 
-export { wsLink };
+//#endregion
+export { createWSClient, wsLink };
+//# sourceMappingURL=wsLink.mjs.map

package/dist/links/wsLink/wsLink.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsLink.mjs","names":["opts: WebSocketLinkOptions<TRouter>"],"sources":["../../../src/links/wsLink/wsLink.ts"],"sourcesContent":["import { observable } from '@trpc/server/observable';\nimport type {\n  AnyRouter,\n  inferClientTypes,\n} from '@trpc/server/unstable-core-do-not-import';\nimport type { TransformerOptions } from '../../unstable-internals';\nimport { getTransformer } from '../../unstable-internals';\nimport type { TRPCLink } from '../types';\nimport type {\n  TRPCWebSocketClient,\n  WebSocketClientOptions,\n} from './createWsClient';\nimport { createWSClient } from './createWsClient';\n\nexport type WebSocketLinkOptions<TRouter extends AnyRouter> = {\n  client: TRPCWebSocketClient;\n} & TransformerOptions<inferClientTypes<TRouter>>;\n\nexport function wsLink<TRouter extends AnyRouter>(\n  opts: WebSocketLinkOptions<TRouter>,\n): TRPCLink<TRouter> {\n  const { client } = opts;\n  const transformer = getTransformer(opts.transformer);\n  return () => {\n    return ({ op }) => {\n      return observable((observer) => {\n        const connStateSubscription =\n          op.type === 'subscription'\n            ? client.connectionState.subscribe({\n                next(result) {\n                  observer.next({\n                    result,\n                    context: op.context,\n                  });\n                },\n              })\n            : null;\n\n        const requestSubscription = client\n          .request({\n            op,\n            transformer,\n          })\n          .subscribe(observer);\n\n        return () => {\n          requestSubscription.unsubscribe();\n          connStateSubscription?.unsubscribe();\n        };\n      });\n    };\n  };\n}\n\nexport { TRPCWebSocketClient, WebSocketClientOptions, createWSClient };\n"],"mappings":";;;;;AAkBA,SAAgB,OACdA,MACmB;CACnB,MAAM,EAAE,QAAQ,GAAG;CACnB,MAAM,cAAc,eAAe,KAAK,YAAY;AACpD,QAAO,MAAM;AACX,SAAO,CAAC,EAAE,IAAI,KAAK;AACjB,UAAO,WAAW,CAAC,aAAa;IAC9B,MAAM,wBACJ,GAAG,SAAS,iBACR,OAAO,gBAAgB,UAAU,EAC/B,KAAK,QAAQ;AACX,cAAS,KAAK;MACZ;MACA,SAAS,GAAG;KACb,EAAC;IACH,EACF,EAAC,GACF;IAEN,MAAM,sBAAsB,OACzB,QAAQ;KACP;KACA;IACD,EAAC,CACD,UAAU,SAAS;AAEtB,WAAO,MAAM;AACX,yBAAoB,aAAa;AACjC,4BAAuB,aAAa;IACrC;GACF,EAAC;EACH;CACF;AACF"}

package/dist/links.js

@@ -0,0 +1,11 @@
+const require__Users_julius_dev_trpc_packages_client_src_links_internals_contentTypes = require('./links/internals/contentTypes.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_httpBatchLink = require('./links/httpBatchLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_httpBatchStreamLink = require('./links/httpBatchStreamLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_httpLink = require('./links/httpLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_loggerLink = require('./links/loggerLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_splitLink = require('./links/splitLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_wsLink_createWsClient = require('./links/wsLink/createWsClient.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_wsLink_wsLink = require('./links/wsLink/wsLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_httpSubscriptionLink = require('./links/httpSubscriptionLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_retryLink = require('./links/retryLink.js');
+const require__Users_julius_dev_trpc_packages_client_src_links_localLink = require('./links/localLink.js');

package/dist/links.mjs

@@ -0,0 +1,11 @@
+import { isFormData, isNonJsonSerializable, isOctetType } from "./links/internals/contentTypes.mjs";
+import { httpBatchLink } from "./links/httpBatchLink.mjs";
+import { httpBatchStreamLink, unstable_httpBatchStreamLink } from "./links/httpBatchStreamLink.mjs";
+import { httpLink } from "./links/httpLink.mjs";
+import { loggerLink } from "./links/loggerLink.mjs";
+import { splitLink } from "./links/splitLink.mjs";
+import { createWSClient } from "./links/wsLink/createWsClient.mjs";
+import { wsLink } from "./links/wsLink/wsLink.mjs";
+import { httpSubscriptionLink, unstable_httpSubscriptionLink } from "./links/httpSubscriptionLink.mjs";
+import { retryLink } from "./links/retryLink.mjs";
+import { experimental_localLink } from "./links/localLink.mjs";