@trpc/client 11.0.0-rc.772 → 11.0.0-rc.781

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

@@ -0,0 +1,79 @@
+import type { UrlOptionsWithConnectionParams } from '@trpc/client/links/internals/urlWithConnectionParams';
+interface PingPongOptions {
+    /**
+     * The interval (in milliseconds) between "PING" messages.
+     */
+    intervalMs: number;
+    /**
+     * The timeout (in milliseconds) to wait for a "PONG" response before closing the connection.
+     */
+    pongTimeoutMs: number;
+}
+export interface WebSocketConnectionOptions {
+    WebSocketPonyfill?: typeof WebSocket;
+    urlOptions: UrlOptionsWithConnectionParams;
+    keepAlive: PingPongOptions & {
+        enabled: boolean;
+    };
+}
+/**
+ * Manages a WebSocket connection with support for reconnection, keep-alive mechanisms,
+ * and observable state tracking.
+ */
+export declare class WsConnection {
+    static connectCount: number;
+    id: number;
+    private readonly WebSocketPonyfill;
+    private readonly urlOptions;
+    private readonly keepAliveOpts;
+    readonly wsObservable: import("@trpc/server/observable").BehaviorSubject<WebSocket | null>;
+    constructor(opts: WebSocketConnectionOptions);
+    get ws(): WebSocket | null;
+    private set ws(value);
+    /**
+     * Checks if the WebSocket connection is open and ready to communicate.
+     */
+    isOpen(): this is {
+        ws: WebSocket;
+    };
+    /**
+     * Checks if the WebSocket connection is closed or in the process of closing.
+     */
+    isClosed(): this is {
+        ws: WebSocket;
+    };
+    /**
+     * 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.
+     */
+    private openPromise;
+    open(): Promise<void>;
+    /**
+     * Closes the WebSocket connection gracefully.
+     * Waits for any ongoing open operation to complete before closing.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Provides a backward-compatible representation of the connection state.
+ */
+export declare function backwardCompatibility(connection: WsConnection): {
+    readonly id: number;
+    readonly state: "open";
+    readonly ws: WebSocket;
+} | {
+    readonly id: number;
+    readonly state: "closed";
+    readonly ws: WebSocket;
+} | {
+    readonly id: number;
+    readonly state: "connecting";
+    readonly ws: WebSocket;
+} | null;
+export {};
+//# sourceMappingURL=wsConnection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnection.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/wsConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,sDAAsD,CAAC;AAqB3G,UAAU,eAAe;IACvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAuDD,MAAM,WAAW,0BAA0B;IACzC,iBAAiB,CAAC,EAAE,OAAO,SAAS,CAAC;IACrC,UAAU,EAAE,8BAA8B,CAAC;IAC3C,SAAS,EAAE,eAAe,GAAG;QAC3B,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED;;;GAGG;AACH,qBAAa,YAAY;IACvB,MAAM,CAAC,YAAY,SAAK;IACjB,EAAE,SAA+B;IAExC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0C;IACxE,SAAgB,YAAY,sEAA2C;gBAE3D,IAAI,EAAE,0BAA0B;IAY5C,IAAW,EAAE,qBAEZ;IAED,OAAO,KAAK,EAAE,QAEb;IAED;;OAEG;IACI,MAAM,IAAI,IAAI,IAAI;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAI1C;;OAEG;IACI,QAAQ,IAAI,IAAI,IAAI;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAQ5C;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW,CAA8B;IACpC,IAAI;IAgCjB;;;OAGG;IACU,KAAK;CAOnB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,YAAY;;;;;;;;;;;;SA0B7D"}

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

@@ -0,0 +1,181 @@
+'use strict';
+
+var observable = require('@trpc/server/observable');
+var utils = require('./utils.js');
+
+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;
+}
+/**
+ * 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 } = utils.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);
+    });
+}
+/**
+ * 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;
+    }
+    /**
+   * 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 = utils.prepareUrl(this.urlOptions).then((url)=>new this.WebSocketPonyfill(url));
+        this.openPromise = wsPromise.then(asyncWsOpen);
+        this.ws = await wsPromise;
+        // Setup ping listener
+        this.ws.addEventListener('message', function({ data }) {
+            if (data === 'PING') {
+                this.send('PONG');
+            }
+        });
+        if (this.keepAliveOpts.enabled) {
+            setupPingInterval(this.ws, this.keepAliveOpts);
+        }
+        this.ws.addEventListener('close', ()=>{
+            this.ws = null;
+        });
+        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", observable.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);
+/**
+ * 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
+    };
+}
+
+exports.WsConnection = WsConnection;
+exports.backwardCompatibility = backwardCompatibility;

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

@@ -0,0 +1,178 @@
+import { behaviorSubject } from '@trpc/server/observable';
+import { prepareUrl, withResolvers } from './utils.mjs';
+
+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;
+}
+/**
+ * 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);
+    });
+}
+/**
+ * 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;
+    }
+    /**
+   * 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(asyncWsOpen);
+        this.ws = await wsPromise;
+        // Setup ping listener
+        this.ws.addEventListener('message', function({ data }) {
+            if (data === 'PING') {
+                this.send('PONG');
+            }
+        });
+        if (this.keepAliveOpts.enabled) {
+            setupPingInterval(this.ws, this.keepAliveOpts);
+        }
+        this.ws.addEventListener('close', ()=>{
+            this.ws = null;
+        });
+        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);
+/**
+ * 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
+    };
+}
+
+export { WsConnection, backwardCompatibility };

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

@@ -0,0 +1,11 @@
+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;
+} & TransformerOptions<inferClientTypes<TRouter>>;
+export declare function wsLink<TRouter extends AnyRouter>(opts: WebSocketLinkOptions<TRouter>): TRPCLink<TRouter>;
+export { TRPCWebSocketClient, WebSocketClientOptions, createWSClient };
+//# sourceMappingURL=wsLink.d.ts.map

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

@@ -0,0 +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"}

package/dist/links/wsLink/wsLink.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var observable = require('@trpc/server/observable');
+var transformer = require('../../internals/transformer.js');
+var createWsClient = require('./createWsClient.js');
+
+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();
+                };
+            });
+        };
+    };
+}
+
+exports.createWSClient = createWsClient.createWSClient;
+exports.wsLink = wsLink;

package/dist/links/wsLink/wsLink.mjs

@@ -0,0 +1,32 @@
+import { observable } from '@trpc/server/observable';
+import { getTransformer } from '../../internals/transformer.mjs';
+export { createWSClient } from './createWsClient.mjs';
+
+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();
+                };
+            });
+        };
+    };
+}
+
+export { wsLink };

package/dist/links.d.ts

@@ -5,7 +5,7 @@ export * from './links/httpBatchStreamLink';
 export * from './links/httpLink';
 export * from './links/loggerLink';
 export * from './links/splitLink';
-export * from './links/wsLink';
+export * from './links/wsLink/wsLink';
 export * from './links/httpSubscriptionLink';
 export * from './links/retryLink';
 //# sourceMappingURL=links.d.ts.map

package/dist/links.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../src/links.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAE9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC"}

package/links/wsLink/wsLink/index.d.ts

@@ -0,0 +1 @@
+export * from '../../../dist/links/wsLink/wsLink';

package/links/wsLink/wsLink/index.js

@@ -0,0 +1 @@
+module.exports = require('../../../dist/links/wsLink/wsLink');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/client",
-  "version": "11.0.0-rc.772+6627c5a96",
+  "version": "11.0.0-rc.781+df4d4ede3",
   "description": "The tRPC client library",
   "author": "KATT",
   "license": "MIT",
@@ -55,10 +55,10 @@
       "require": "./dist/links/splitLink.js",
       "default": "./dist/links/splitLink.js"
     },
-    "./links/wsLink": {
-      "import": "./dist/links/wsLink.mjs",
-      "require": "./dist/links/wsLink.js",
-      "default": "./dist/links/wsLink.js"
+    "./links/wsLink/wsLink": {
+      "import": "./dist/links/wsLink/wsLink.mjs",
+      "require": "./dist/links/wsLink/wsLink.js",
+      "default": "./dist/links/wsLink/wsLink.js"
     },
     "./unstable-internals": {
       "import": "./dist/unstable-internals.mjs",
@@ -77,11 +77,11 @@
     "!**/__tests__"
   ],
   "peerDependencies": {
-    "@trpc/server": "11.0.0-rc.772+6627c5a96",
+    "@trpc/server": "11.0.0-rc.781+df4d4ede3",
     "typescript": ">=5.7.2"
   },
   "devDependencies": {
-    "@trpc/server": "11.0.0-rc.772+6627c5a96",
+    "@trpc/server": "11.0.0-rc.781+df4d4ede3",
     "@types/isomorphic-fetch": "^0.0.39",
     "@types/node": "^22.9.0",
     "eslint": "^9.13.0",
@@ -99,5 +99,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "6627c5a965a2081cd28cfad24d6712e985f0ad5f"
+  "gitHead": "df4d4ede3492c91a0846f683ef2f1d0ffeed3b09"
 }

package/src/links/wsLink/createWsClient.ts

@@ -0,0 +1,10 @@
+import type { WebSocketClientOptions } from './wsClient/options';
+import { WsClient } from './wsClient/wsClient';
+
+export function createWSClient(opts: WebSocketClientOptions) {
+  return new WsClient(opts);
+}
+
+export type TRPCWebSocketClient = ReturnType<typeof createWSClient>;
+
+export { WebSocketClientOptions };