@trpc/client 11.4.1 → 11.4.2

package/dist/{wsLink-DhJ50EC5.cjs → wsLink-BcTLPVgc.cjs}

@@ -1,6 +1,7 @@
 const require_chunk = require('./chunk-DWy1uDak.cjs');
-const require_TRPCClientError = require('./TRPCClientError-CGgRtttT.cjs');
-const require_unstable_internals = require('./unstable-internals-CYBH4jbF.cjs');
+const require_objectSpread2$1 = require('./objectSpread2-Bsvh_OqM.cjs');
+const require_TRPCClientError = require('./TRPCClientError-Dey88Uiy.cjs');
+const require_unstable_internals = require('./unstable-internals-M84gUQCV.cjs');
 const __trpc_server_observable = require_chunk.__toESM(require("@trpc/server/observable"));
 const __trpc_server_unstable_core_do_not_import = require_chunk.__toESM(require("@trpc/server/unstable-core-do-not-import"));
 
@@ -35,6 +36,7 @@ const resultOf = (value, ...args) => {
 
 //#endregion
 //#region src/links/wsLink/wsClient/utils.ts
+var import_defineProperty$3 = require_chunk.__toESM(require_objectSpread2$1.require_defineProperty(), 1);
 var TRPCWebSocketClosedError = class TRPCWebSocketClosedError extends Error {
 	constructor(opts) {
 		super(opts.message, { cause: opts.cause });
@@ -47,10 +49,10 @@ var TRPCWebSocketClosedError = class TRPCWebSocketClosedError extends Error {
 * Useful for scenarios where the timeout duration is reset dynamically based on events.
 */
 var ResettableTimeout = class {
-	timeout;
 	constructor(onTimeout, timeoutMs) {
 		this.onTimeout = onTimeout;
 		this.timeoutMs = timeoutMs;
+		(0, import_defineProperty$3.default)(this, "timeout", void 0);
 	}
 	/**
 	* Resets the current timeout, restarting it with the same duration.
@@ -105,6 +107,7 @@ async function buildConnectionMessage(connectionParams) {
 
 //#endregion
 //#region src/links/wsLink/wsClient/requestManager.ts
+var import_defineProperty$2 = require_chunk.__toESM(require_objectSpread2$1.require_defineProperty(), 1);
 /**
 * Manages WebSocket requests, tracking their lifecycle and providing utility methods
 * for handling outgoing and pending requests.
@@ -114,16 +117,10 @@ async function buildConnectionMessage(connectionParams) {
 *   For subscriptions, multiple responses may be received until the subscription is closed.
 */
 var RequestManager = class {
-	/**
-	* Stores requests that are outgoing, meaning they are registered but not yet sent over the WebSocket.
-	*/
-	outgoingRequests = new Array();
-	/**
-	* Stores requests that are pending (in flight), meaning they have been sent over the WebSocket
-	* and are awaiting responses. For subscriptions, this includes requests
-	* that may receive multiple responses.
-	*/
-	pendingRequests = {};
+	constructor() {
+		(0, import_defineProperty$2.default)(this, "outgoingRequests", new Array());
+		(0, import_defineProperty$2.default)(this, "pendingRequests", {});
+	}
 	/**
 	* Registers a new request by adding it to the outgoing queue and setting up
 	* callbacks for lifecycle events such as completion or error.
@@ -238,6 +235,7 @@ var RequestManager = class {
 
 //#endregion
 //#region src/links/wsLink/wsClient/wsConnection.ts
+var import_defineProperty$1 = require_chunk.__toESM(require_objectSpread2$1.require_defineProperty(), 1);
 /**
 * Opens a WebSocket connection asynchronously and returns a promise
 * that resolves when the connection is successfully established.
@@ -299,14 +297,15 @@ function setupPingInterval(ws, { intervalMs, pongTimeoutMs }) {
 * and observable state tracking.
 */
 var WsConnection = class WsConnection {
-	static connectCount = 0;
-	id = ++WsConnection.connectCount;
-	WebSocketPonyfill;
-	urlOptions;
-	keepAliveOpts;
-	wsObservable = (0, __trpc_server_observable.behaviorSubject)(null);
 	constructor(opts) {
-		this.WebSocketPonyfill = opts.WebSocketPonyfill ?? WebSocket;
+		var _opts$WebSocketPonyfi;
+		(0, import_defineProperty$1.default)(this, "id", ++WsConnection.connectCount);
+		(0, import_defineProperty$1.default)(this, "WebSocketPonyfill", void 0);
+		(0, import_defineProperty$1.default)(this, "urlOptions", void 0);
+		(0, import_defineProperty$1.default)(this, "keepAliveOpts", void 0);
+		(0, import_defineProperty$1.default)(this, "wsObservable", (0, __trpc_server_observable.behaviorSubject)(null));
+		(0, import_defineProperty$1.default)(this, "openPromise", null);
+		this.WebSocketPonyfill = (_opts$WebSocketPonyfi = opts.WebSocketPonyfill) !== null && _opts$WebSocketPonyfi !== void 0 ? _opts$WebSocketPonyfi : 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;
@@ -329,36 +328,27 @@ var WsConnection = class WsConnection {
 	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;
+		var _this = this;
+		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);
+			if (_this.keepAliveOpts.enabled) setupPingInterval(ws, _this.keepAliveOpts);
 			ws.addEventListener("close", () => {
-				if (this.ws === ws) this.ws = null;
+				if (_this.ws === ws) _this.ws = null;
 			});
 			await asyncWsOpen(ws);
-			if (this.urlOptions.connectionParams) ws.send(await buildConnectionMessage(this.urlOptions.connectionParams));
+			if (_this.urlOptions.connectionParams) ws.send(await buildConnectionMessage(_this.urlOptions.connectionParams));
 		});
 		try {
-			await this.openPromise;
+			await _this.openPromise;
 		} finally {
-			this.openPromise = null;
+			_this.openPromise = null;
 		}
 	}
 	/**
@@ -366,13 +356,16 @@ var WsConnection = class WsConnection {
 	* Waits for any ongoing open operation to complete before closing.
 	*/
 	async close() {
+		var _this2 = this;
 		try {
-			await this.openPromise;
+			await _this2.openPromise;
 		} finally {
-			this.ws?.close();
+			var _this$ws;
+			(_this$ws = _this2.ws) === null || _this$ws === void 0 || _this$ws.close();
 		}
 	}
 };
+(0, import_defineProperty$1.default)(WsConnection, "connectCount", 0);
 /**
 * Provides a backward-compatible representation of the connection state.
 */
@@ -397,32 +390,30 @@ function backwardCompatibility(connection) {
 
 //#endregion
 //#region src/links/wsLink/wsClient/wsClient.ts
+var import_defineProperty = require_chunk.__toESM(require_objectSpread2$1.require_defineProperty(), 1);
+var import_objectSpread2 = require_chunk.__toESM(require_objectSpread2$1.require_objectSpread2(), 1);
 /**
 * A WebSocket client for managing TRPC operations, supporting lazy initialization,
 * reconnection, keep-alive, and request management.
 */
 var WsClient = class {
-	/**
-	* Observable tracking the current connection state, including errors.
-	*/
-	connectionState;
-	allowReconnect = false;
-	requestManager = new RequestManager();
-	activeConnection;
-	reconnectRetryDelay;
-	inactivityTimeout;
-	callbacks;
-	lazyMode;
 	constructor(opts) {
+		var _opts$retryDelayMs;
+		(0, import_defineProperty.default)(this, "connectionState", void 0);
+		(0, import_defineProperty.default)(this, "allowReconnect", false);
+		(0, import_defineProperty.default)(this, "requestManager", new RequestManager());
+		(0, import_defineProperty.default)(this, "activeConnection", void 0);
+		(0, import_defineProperty.default)(this, "reconnectRetryDelay", void 0);
+		(0, import_defineProperty.default)(this, "inactivityTimeout", void 0);
+		(0, import_defineProperty.default)(this, "callbacks", void 0);
+		(0, import_defineProperty.default)(this, "lazyMode", void 0);
+		(0, import_defineProperty.default)(this, "reconnecting", null);
 		this.callbacks = {
 			onOpen: opts.onOpen,
 			onClose: opts.onClose,
 			onError: opts.onError
 		};
-		const lazyOptions = {
-			...lazyDefaults,
-			...opts.lazy
-		};
+		const lazyOptions = (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, lazyDefaults), opts.lazy);
 		this.inactivityTimeout = new ResettableTimeout(() => {
 			if (this.requestManager.hasOutgoingRequests() || this.requestManager.hasPendingRequests()) {
 				this.inactivityTimeout.reset();
@@ -433,16 +424,13 @@ var WsClient = class {
 		this.activeConnection = new WsConnection({
 			WebSocketPonyfill: opts.WebSocket,
 			urlOptions: opts,
-			keepAlive: {
-				...keepAliveDefaults,
-				...opts.keepAlive
-			}
+			keepAlive: (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, keepAliveDefaults), opts.keepAlive)
 		});
 		this.activeConnection.wsObservable.subscribe({ next: (ws) => {
 			if (!ws) return;
 			this.setupWebSocketListeners(ws);
 		} });
-		this.reconnectRetryDelay = opts.retryDelayMs ?? exponentialBackoff;
+		this.reconnectRetryDelay = (_opts$retryDelayMs = opts.retryDelayMs) !== null && _opts$retryDelayMs !== void 0 ? _opts$retryDelayMs : exponentialBackoff;
 		this.lazyMode = lazyOptions.enabled;
 		this.connectionState = (0, __trpc_server_observable.behaviorSubject)({
 			type: "state",
@@ -456,20 +444,21 @@ var WsClient = class {
 	* the connection state accordingly.
 	*/
 	async open() {
-		this.allowReconnect = true;
-		if (this.connectionState.get().state !== "connecting") this.connectionState.next({
+		var _this = this;
+		_this.allowReconnect = true;
+		if (_this.connectionState.get().state !== "connecting") _this.connectionState.next({
 			type: "state",
 			state: "connecting",
 			error: null
 		});
 		try {
-			await this.activeConnection.open();
+			await _this.activeConnection.open();
 		} catch (error) {
-			this.reconnect(new TRPCWebSocketClosedError({
+			_this.reconnect(new TRPCWebSocketClosedError({
 				message: "Initialization error",
 				cause: error
 			}));
-			return this.reconnecting;
+			return _this.reconnecting;
 		}
 	}
 	/**
@@ -477,15 +466,16 @@ var WsClient = class {
 	* Ensures all outgoing and pending requests are properly finalized.
 	*/
 	async close() {
-		this.allowReconnect = false;
-		this.inactivityTimeout.stop();
+		var _this2 = this;
+		_this2.allowReconnect = false;
+		_this2.inactivityTimeout.stop();
 		const requestsToAwait = [];
-		for (const request of this.requestManager.getRequests()) if (request.message.method === "subscription") request.callbacks.complete();
+		for (const request of _this2.requestManager.getRequests()) if (request.message.method === "subscription") request.callbacks.complete();
 		else if (request.state === "outgoing") request.callbacks.error(require_TRPCClientError.TRPCClientError.from(new TRPCWebSocketClosedError({ message: "Closed before connection was established" })));
 		else requestsToAwait.push(request.end);
 		await Promise.all(requestsToAwait).catch(() => null);
-		await this.activeConnection.close().catch(() => null);
-		this.connectionState.next({
+		await _this2.activeConnection.close().catch(() => null);
+		_this2.connectionState.next({
 			type: "state",
 			state: "idle",
 			error: null
@@ -511,37 +501,29 @@ var WsClient = class {
 					path,
 					lastEventId
 				}
-			}, {
-				...observer,
-				next(event) {
-					const transformed = (0, __trpc_server_unstable_core_do_not_import.transformResult)(event, transformer.output);
-					if (!transformed.ok) {
-						observer.error(require_TRPCClientError.TRPCClientError.from(transformed.error));
-						return;
-					}
-					observer.next({ result: transformed.result });
+			}, (0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, observer), {}, { next(event) {
+				const transformed = (0, __trpc_server_unstable_core_do_not_import.transformResult)(event, transformer.output);
+				if (!transformed.ok) {
+					observer.error(require_TRPCClientError.TRPCClientError.from(transformed.error));
+					return;
 				}
-			});
+				observer.next({ result: transformed.result });
+			} }));
 			return () => {
 				abort();
 				if (type === "subscription" && this.activeConnection.isOpen()) this.send({
 					id,
 					method: "subscription.stop"
 				});
-				signal?.removeEventListener("abort", abort);
+				signal === null || signal === void 0 || signal.removeEventListener("abort", abort);
 			};
 		});
 	}
 	get connection() {
 		return backwardCompatibility(this.activeConnection);
 	}
-	/**
-	* Manages the reconnection process for the WebSocket using retry logic.
-	* Ensures that only one reconnection attempt is active at a time by tracking the current
-	* reconnection state in the `reconnecting` promise.
-	*/
-	reconnecting = null;
 	reconnect(closedError) {
+		var _this3 = this;
 		this.connectionState.next({
 			type: "state",
 			state: "connecting",
@@ -550,25 +532,26 @@ var WsClient = class {
 		if (this.reconnecting) return;
 		const tryReconnect = async (attemptIndex) => {
 			try {
-				await (0, __trpc_server_unstable_core_do_not_import.sleep)(this.reconnectRetryDelay(attemptIndex));
-				if (this.allowReconnect) {
-					await this.activeConnection.close();
-					await this.activeConnection.open();
-					if (this.requestManager.hasPendingRequests()) this.send(this.requestManager.getPendingRequests().map(({ message }) => message));
+				await (0, __trpc_server_unstable_core_do_not_import.sleep)(_this3.reconnectRetryDelay(attemptIndex));
+				if (_this3.allowReconnect) {
+					await _this3.activeConnection.close();
+					await _this3.activeConnection.open();
+					if (_this3.requestManager.hasPendingRequests()) _this3.send(_this3.requestManager.getPendingRequests().map(({ message }) => message));
 				}
-				this.reconnecting = null;
-			} catch {
+				_this3.reconnecting = null;
+			} catch (_unused) {
 				await tryReconnect(attemptIndex + 1);
 			}
 		};
 		this.reconnecting = tryReconnect(0);
 	}
 	setupWebSocketListeners(ws) {
+		var _this4 = this;
 		const handleCloseOrError = (cause) => {
 			const reqs = this.requestManager.getPendingRequests();
 			for (const { message, callbacks } of reqs) {
 				if (message.method === "subscription") continue;
-				callbacks.error(require_TRPCClientError.TRPCClientError.from(cause ?? new TRPCWebSocketClosedError({
+				callbacks.error(require_TRPCClientError.TRPCClientError.from(cause !== null && cause !== void 0 ? cause : new TRPCWebSocketClosedError({
 					message: "WebSocket closed",
 					cause
 				})));
@@ -577,9 +560,10 @@ var WsClient = class {
 		};
 		ws.addEventListener("open", () => {
 			(0, __trpc_server_unstable_core_do_not_import.run)(async () => {
-				if (this.lazyMode) this.inactivityTimeout.start();
-				this.callbacks.onOpen?.();
-				this.connectionState.next({
+				var _this$callbacks$onOpe, _this$callbacks;
+				if (_this4.lazyMode) _this4.inactivityTimeout.start();
+				(_this$callbacks$onOpe = (_this$callbacks = _this4.callbacks).onOpen) === null || _this$callbacks$onOpe === void 0 || _this$callbacks$onOpe.call(_this$callbacks);
+				_this4.connectionState.next({
 					type: "state",
 					state: "pending",
 					error: null
@@ -600,16 +584,18 @@ var WsClient = class {
 			this.handleResponseMessage(incomingMessage);
 		});
 		ws.addEventListener("close", (event) => {
+			var _this$callbacks$onClo, _this$callbacks2;
 			handleCloseOrError(event);
-			this.callbacks.onClose?.(event);
+			(_this$callbacks$onClo = (_this$callbacks2 = this.callbacks).onClose) === null || _this$callbacks$onClo === void 0 || _this$callbacks$onClo.call(_this$callbacks2, event);
 			if (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) this.reconnect(new TRPCWebSocketClosedError({
 				message: "WebSocket closed",
 				cause: event
 			}));
 		});
 		ws.addEventListener("error", (event) => {
+			var _this$callbacks$onErr, _this$callbacks3;
 			handleCloseOrError(event);
-			this.callbacks.onError?.(event);
+			(_this$callbacks$onErr = (_this$callbacks3 = this.callbacks).onError) === null || _this$callbacks$onErr === void 0 || _this$callbacks$onErr.call(_this$callbacks3, event);
 			this.reconnect(new TRPCWebSocketClosedError({
 				message: "WebSocket closed",
 				cause: event
@@ -647,12 +633,13 @@ var WsClient = class {
 	* @returns A function to abort the batched request.
 	*/
 	batchSend(message, callbacks) {
+		var _this5 = this;
 		this.inactivityTimeout.reset();
 		(0, __trpc_server_unstable_core_do_not_import.run)(async () => {
-			if (!this.activeConnection.isOpen()) await this.open();
+			if (!_this5.activeConnection.isOpen()) await _this5.open();
 			await (0, __trpc_server_unstable_core_do_not_import.sleep)(0);
-			if (!this.requestManager.hasOutgoingRequests()) return;
-			this.send(this.requestManager.flush().map(({ message: message$1 }) => message$1));
+			if (!_this5.requestManager.hasOutgoingRequests()) return;
+			_this5.send(_this5.requestManager.flush().map(({ message: message$1 }) => message$1));
 		}).catch((err) => {
 			this.requestManager.delete(message.id);
 			callbacks.error(require_TRPCClientError.TRPCClientError.from(err));
@@ -687,7 +674,7 @@ function wsLink(opts) {
 				}).subscribe(observer);
 				return () => {
 					requestSubscription.unsubscribe();
-					connStateSubscription?.unsubscribe();
+					connStateSubscription === null || connStateSubscription === void 0 || connStateSubscription.unsubscribe();
 				};
 			});
 		};