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

package/src/links/wsLink/wsLink.ts

@@ -0,0 +1,55 @@
+import { observable } from '@trpc/server/observable';
+import type {
+  AnyRouter,
+  inferClientTypes,
+} from '@trpc/server/unstable-core-do-not-import';
+import type { TransformerOptions } from '../../unstable-internals';
+import { getTransformer } 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 function wsLink<TRouter extends AnyRouter>(
+  opts: WebSocketLinkOptions<TRouter>,
+): TRPCLink<TRouter> {
+  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 { TRPCWebSocketClient, WebSocketClientOptions, createWSClient };

package/src/links.ts

@@ -6,7 +6,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';
 

package/dist/links/wsLink.d.ts

@@ -1,125 +0,0 @@
-import type { Observer, UnsubscribeFn } from '@trpc/server/observable';
-import type { AnyRouter, inferClientTypes, inferRouterError, TRPCResponseMessage } from '@trpc/server/unstable-core-do-not-import';
-import { TRPCClientError } from '../TRPCClientError';
-import type { TransformerOptions } from '../unstable-internals';
-import type { TRPCConnectionState } from './internals/subscriptions';
-import { type UrlOptionsWithConnectionParams } from './internals/urlWithConnectionParams';
-import type { Operation, TRPCLink } from './types';
-type WSCallbackResult<TRouter extends AnyRouter, TOutput> = TRPCResponseMessage<TOutput, inferRouterError<TRouter>>;
-type WSCallbackObserver<TRouter extends AnyRouter, TOutput> = Observer<WSCallbackResult<TRouter, TOutput>, TRPCClientError<TRouter>>;
-declare const exponentialBackoff: (attemptIndex: number) => number;
-export interface WebSocketClientOptions extends UrlOptionsWithConnectionParams {
-    /**
-     * Ponyfill which WebSocket implementation to use
-     */
-    WebSocket?: typeof WebSocket;
-    /**
-     * The number of milliseconds before a reconnect is attempted.
-     * @default {@link exponentialBackoff}
-     */
-    retryDelayMs?: typeof exponentialBackoff;
-    /**
-     * Triggered when a WebSocket connection is established
-     */
-    onOpen?: () => void;
-    /**
-     * Triggered when a WebSocket connection encounters an error
-     */
-    onError?: (evt?: Event) => void;
-    /**
-     * Triggered when a WebSocket connection is closed
-     */
-    onClose?: (cause?: {
-        code?: number;
-    }) => void;
-    /**
-     * Lazy mode will close the WebSocket automatically after a period of inactivity (no messages sent or received and no pending requests)
-     */
-    lazy?: {
-        /**
-         * Enable lazy mode
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * Close the WebSocket after this many milliseconds
-         * @default 0
-         */
-        closeMs: number;
-    };
-    /**
-     * Send ping messages to the server and kill the connection if no pong message is returned
-     */
-    keepAlive?: {
-        /**
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * Send a ping message every this many milliseconds
-         * @default 5_000
-         */
-        intervalMs?: number;
-        /**
-         * Close the WebSocket after this many milliseconds if the server does not respond
-         * @default 1_000
-         */
-        pongTimeoutMs?: number;
-    };
-}
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */
-export declare function createWSClient(opts: WebSocketClientOptions): {
-    close: () => void;
-    request: (opts: {
-        op: Operation;
-        callbacks: WSCallbackObserver<AnyRouter, unknown>;
-        lastEventId: string | undefined;
-    }) => UnsubscribeFn;
-    readonly connection: ({
-        id: number;
-    } & ({
-        state: "open";
-        ws: WebSocket;
-    } | {
-        state: "closed";
-        ws: WebSocket;
-    } | {
-        state: "connecting";
-        ws?: WebSocket;
-    })) | null;
-    /**
-     * Reconnect to the WebSocket server
-     */
-    reconnect: (cause: Error | null) => void;
-    connectionState: import("@trpc/server/observable").BehaviorSubject<TRPCConnectionState<TRPCClientError<AnyRouter>>>;
-};
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */
-export type TRPCWebSocketClient = ReturnType<typeof createWSClient>;
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */
-export type WebSocketLinkOptions<TRouter extends AnyRouter> = {
-    client: TRPCWebSocketClient;
-} & TransformerOptions<inferClientTypes<TRouter>>;
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */
-export declare function wsLink<TRouter extends AnyRouter>(opts: WebSocketLinkOptions<TRouter>): TRPCLink<TRouter>;
-export {};
-//# sourceMappingURL=wsLink.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"wsLink.d.ts","sourceRoot":"","sources":["../../src/links/wsLink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGvE,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAMhB,mBAAmB,EACpB,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAInD,KAAK,gBAAgB,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,IAAI,mBAAmB,CAC7E,OAAO,EACP,gBAAgB,CAAC,OAAO,CAAC,CAC1B,CAAC;AAEF,KAAK,kBAAkB,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,IAAI,QAAQ,CACpE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,EAClC,eAAe,CAAC,OAAO,CAAC,CACzB,CAAC;AAEF,QAAA,MAAM,kBAAkB,iBAAkB,MAAM,WACoB,CAAC;AAErE,MAAM,WAAW,sBAAuB,SAAQ,8BAA8B;IAC5E;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAC7B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,kBAAkB,CAAC;IACzC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAChC;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9C;;OAEG;IACH,IAAI,CAAC,EAAE;QACL;;;WAGG;QACH,OAAO,EAAE,OAAO,CAAC;QACjB;;;WAGG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF;;OAEG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,OAAO,EAAE,OAAO,CAAC;QACjB;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB;;;WAGG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAQD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,sBAAsB;;oBA2blC;QACrB,EAAE,EAAE,SAAS,CAAC;QACd,SAAS,yCAAa;QACtB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;KACjC,KAAG,aAAa;;YA9YX,MAAM;;eAGC,MAAM;YACT,SAAS;;eAGN,QAAQ;YACX,SAAS;;eAGN,YAAY;aACd,SAAS;;IA0clB;;OAEG;uBA1YqB,KAAK,GAAG,IAAI;;EA8YvC;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,CAAC,OAAO,SAAS,SAAS,IAAI;IAC5D,MAAM,EAAE,mBAAmB,CAAC;CAC7B,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAgBlD;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,OAAO,SAAS,SAAS,EAC9C,IAAI,EAAE,oBAAoB,CAAC,OAAO,CAAC,GAClC,QAAQ,CAAC,OAAO,CAAC,CA2DnB"}

package/dist/links/wsLink.js

@@ -1,498 +0,0 @@
-'use strict';
-
-var observable = require('@trpc/server/observable');
-var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
-var TRPCClientError = require('../TRPCClientError.js');
-var transformer = require('../internals/transformer.js');
-var urlWithConnectionParams = require('./internals/urlWithConnectionParams.js');
-
-const run = (fn)=>fn();
-const exponentialBackoff = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);
-const lazyDefaults = {
-    enabled: false,
-    closeMs: 0
-};
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */ function createWSClient(opts) {
-    const { WebSocket: WebSocketImpl = WebSocket, retryDelayMs: retryDelayFn = exponentialBackoff } = opts;
-    const lazyOpts = {
-        ...lazyDefaults,
-        ...opts.lazy
-    };
-    /* istanbul ignore next -- @preserve */ if (!WebSocketImpl) {
-        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");
-    }
-    /**
-   * outgoing messages buffer whilst not open
-   */ let outgoing = [];
-    const pendingRequests = Object.create(null);
-    let connectAttempt = 0;
-    let connectTimer = undefined;
-    let connectionIndex = 0;
-    let lazyDisconnectTimer = undefined;
-    let activeConnection = lazyOpts.enabled ? null : createConnection();
-    const initState = activeConnection ? {
-        type: 'state',
-        state: 'connecting',
-        error: null
-    } : {
-        type: 'state',
-        state: 'idle',
-        error: null
-    };
-    const connectionState = observable.behaviorSubject(initState);
-    /**
-   * tries to send the list of messages
-   */ function dispatch() {
-        if (!activeConnection) {
-            reconnect(null);
-            return;
-        }
-        // using a timeout to batch messages
-        setTimeout(()=>{
-            if (activeConnection?.state !== 'open') {
-                return;
-            }
-            for (const pending of Object.values(pendingRequests)){
-                if (!pending.connection) {
-                    pending.connection = activeConnection;
-                }
-            }
-            if (outgoing.length === 1) {
-                // single send
-                activeConnection.ws.send(JSON.stringify(outgoing.pop()));
-            } else {
-                // batch send
-                activeConnection.ws.send(JSON.stringify(outgoing));
-            }
-            // clear
-            outgoing = [];
-            startLazyDisconnectTimer();
-        });
-    }
-    function tryReconnect(cause) {
-        if (!!connectTimer) {
-            return;
-        }
-        const timeout = retryDelayFn(connectAttempt++);
-        reconnectInMs(timeout, cause);
-    }
-    function hasPendingRequests(conn) {
-        const requests = Object.values(pendingRequests);
-        if (!conn) {
-            return requests.length > 0;
-        }
-        return requests.some((req)=>req.connection === conn);
-    }
-    function reconnect(cause) {
-        if (lazyOpts.enabled && !hasPendingRequests()) {
-            // Skip reconnecting if there aren't pending requests and we're in lazy mode
-            return;
-        }
-        const oldConnection = activeConnection;
-        activeConnection = createConnection();
-        if (oldConnection) {
-            closeIfNoPending(oldConnection);
-        }
-        const currentState = connectionState.get();
-        if (currentState.state !== 'connecting') {
-            connectionState.next({
-                type: 'state',
-                state: 'connecting',
-                error: cause ? TRPCClientError.TRPCClientError.from(cause) : null
-            });
-        }
-    }
-    function reconnectInMs(ms, cause) {
-        if (connectTimer) {
-            return;
-        }
-        connectTimer = setTimeout(()=>{
-            reconnect(cause);
-        }, ms);
-    }
-    function closeIfNoPending(conn) {
-        // disconnect as soon as there are are no pending requests
-        if (!hasPendingRequests(conn)) {
-            conn.ws?.close();
-        }
-    }
-    function resumeSubscriptionOnReconnect(req) {
-        if (outgoing.some((r)=>r.id === req.op.id)) {
-            return;
-        }
-        request({
-            op: req.op,
-            callbacks: req.callbacks,
-            lastEventId: req.lastEventId
-        });
-    }
-    const startLazyDisconnectTimer = ()=>{
-        if (!lazyOpts.enabled) {
-            return;
-        }
-        clearTimeout(lazyDisconnectTimer);
-        lazyDisconnectTimer = setTimeout(()=>{
-            if (!activeConnection) {
-                return;
-            }
-            if (!hasPendingRequests()) {
-                activeConnection.ws?.close();
-                activeConnection = null;
-                connectionState.next({
-                    type: 'state',
-                    state: 'idle',
-                    error: null
-                });
-            }
-        }, lazyOpts.closeMs);
-    };
-    function createConnection() {
-        let pingTimeout = undefined;
-        let pongTimeout = undefined;
-        const self = {
-            id: ++connectionIndex,
-            state: 'connecting'
-        };
-        clearTimeout(lazyDisconnectTimer);
-        function destroy() {
-            const noop = ()=>{
-            // no-op
-            };
-            const { ws } = self;
-            if (ws) {
-                ws.onclose = noop;
-                ws.onerror = noop;
-                ws.onmessage = noop;
-                ws.onopen = noop;
-                ws.close();
-            }
-            self.state = 'closed';
-        }
-        const onCloseOrError = (cause)=>{
-            clearTimeout(pingTimeout);
-            clearTimeout(pongTimeout);
-            self.state = 'closed';
-            if (activeConnection === self) {
-                // connection might have been replaced already
-                tryReconnect(cause);
-            }
-            for (const [key, req] of Object.entries(pendingRequests)){
-                if (req.connection !== self) {
-                    continue;
-                }
-                // The connection was closed either unexpectedly or because of a reconnect
-                if (req.type === 'subscription') {
-                    // Subscriptions will resume after we've reconnected
-                    resumeSubscriptionOnReconnect(req);
-                } else {
-                    // Queries and mutations will error if interrupted
-                    delete pendingRequests[key];
-                    req.callbacks.error?.(TRPCClientError.TRPCClientError.from(cause ?? new TRPCWebSocketClosedError()));
-                }
-            }
-        };
-        const onError = (evt)=>{
-            onCloseOrError(new TRPCWebSocketClosedError({
-                cause: evt
-            }));
-            opts.onError?.(evt);
-        };
-        function connect(url) {
-            if (opts.connectionParams) {
-                // append `?connectionParams=1` when connection params are used
-                const prefix = url.includes('?') ? '&' : '?';
-                url += prefix + 'connectionParams=1';
-            }
-            const ws = new WebSocketImpl(url);
-            self.ws = ws;
-            clearTimeout(connectTimer);
-            connectTimer = undefined;
-            ws.onopen = ()=>{
-                async function sendConnectionParams() {
-                    if (!opts.connectionParams) {
-                        return;
-                    }
-                    const connectMsg = {
-                        method: 'connectionParams',
-                        data: await urlWithConnectionParams.resultOf(opts.connectionParams)
-                    };
-                    ws.send(JSON.stringify(connectMsg));
-                }
-                function handleKeepAlive() {
-                    if (!opts.keepAlive?.enabled) {
-                        return;
-                    }
-                    const { pongTimeoutMs = 1000, intervalMs = 5000 } = opts.keepAlive;
-                    const schedulePing = ()=>{
-                        const schedulePongTimeout = ()=>{
-                            pongTimeout = setTimeout(()=>{
-                                const wasOpen = self.state === 'open';
-                                destroy();
-                                if (wasOpen) {
-                                    opts.onClose?.();
-                                }
-                            }, pongTimeoutMs);
-                        };
-                        pingTimeout = setTimeout(()=>{
-                            ws.send('PING');
-                            schedulePongTimeout();
-                        }, intervalMs);
-                    };
-                    ws.addEventListener('message', ()=>{
-                        clearTimeout(pingTimeout);
-                        clearTimeout(pongTimeout);
-                        schedulePing();
-                    });
-                    schedulePing();
-                }
-                run(async ()=>{
-                    /* istanbul ignore next -- @preserve */ if (activeConnection?.ws !== ws) {
-                        return;
-                    }
-                    handleKeepAlive();
-                    await sendConnectionParams();
-                    connectAttempt = 0;
-                    self.state = 'open';
-                    // Update connection state
-                    connectionState.next({
-                        type: 'state',
-                        state: 'pending',
-                        error: null
-                    });
-                    opts.onOpen?.();
-                    dispatch();
-                }).catch((cause)=>{
-                    ws.close(// "Status codes in the range 3000-3999 are reserved for use by libraries, frameworks, and applications"
-                    3000);
-                    onCloseOrError(new TRPCWebSocketClosedError({
-                        message: 'Initialization error',
-                        cause
-                    }));
-                });
-            };
-            ws.onerror = onError;
-            const handleIncomingRequest = (req)=>{
-                if (self !== activeConnection) {
-                    return;
-                }
-                if (req.method === 'reconnect') {
-                    reconnect(new TRPCWebSocketClosedError({
-                        message: 'Server requested reconnect'
-                    }));
-                    // notify subscribers
-                    for (const pendingReq of Object.values(pendingRequests)){
-                        if (pendingReq.type === 'subscription') {
-                            resumeSubscriptionOnReconnect(pendingReq);
-                        }
-                    }
-                }
-            };
-            const handleIncomingResponse = (data)=>{
-                const req = data.id !== null && pendingRequests[data.id];
-                if (!req) {
-                    // do something?
-                    return;
-                }
-                req.callbacks.next?.(data);
-                if (self === activeConnection && req.connection !== activeConnection) {
-                    // gracefully replace old connection with a new connection
-                    req.connection = self;
-                }
-                if (req.connection !== self) {
-                    // the connection has been replaced
-                    return;
-                }
-                if ('result' in data && data.result.type === 'data' && typeof data.result.id === 'string') {
-                    req.lastEventId = data.result.id;
-                }
-                if ('result' in data && data.result.type === 'stopped' && activeConnection === self) {
-                    req.callbacks.complete();
-                }
-            };
-            ws.onmessage = (event)=>{
-                const { data } = event;
-                if (data === 'PONG') {
-                    return;
-                }
-                if (data === 'PING') {
-                    ws.send('PONG');
-                    return;
-                }
-                startLazyDisconnectTimer();
-                const msg = JSON.parse(data);
-                if ('method' in msg) {
-                    handleIncomingRequest(msg);
-                } else {
-                    handleIncomingResponse(msg);
-                }
-                if (self !== activeConnection) {
-                    // when receiving a message, we close old connection that has no pending requests
-                    closeIfNoPending(self);
-                }
-            };
-            ws.onclose = (event)=>{
-                const wasOpen = self.state === 'open';
-                destroy();
-                onCloseOrError(new TRPCWebSocketClosedError({
-                    cause: event
-                }));
-                if (wasOpen) {
-                    opts.onClose?.(event);
-                }
-            };
-        }
-        Promise.resolve(urlWithConnectionParams.resultOf(opts.url)).then(connect).catch(()=>{
-            onCloseOrError(new Error('Failed to resolve url'));
-        });
-        return self;
-    }
-    function request(opts) {
-        const { op, callbacks, lastEventId } = opts;
-        const { type, input, path, id } = op;
-        const envelope = {
-            id,
-            method: type,
-            params: {
-                input,
-                path,
-                lastEventId
-            }
-        };
-        pendingRequests[id] = {
-            connection: null,
-            type,
-            callbacks,
-            op,
-            lastEventId
-        };
-        // enqueue message
-        outgoing.push(envelope);
-        dispatch();
-        return ()=>{
-            const callbacks = pendingRequests[id]?.callbacks;
-            delete pendingRequests[id];
-            outgoing = outgoing.filter((msg)=>msg.id !== id);
-            callbacks?.complete?.();
-            if (activeConnection?.state === 'open' && op.type === 'subscription') {
-                outgoing.push({
-                    id,
-                    method: 'subscription.stop'
-                });
-                dispatch();
-            }
-            startLazyDisconnectTimer();
-        };
-    }
-    return {
-        close: ()=>{
-            connectAttempt = 0;
-            for (const req of Object.values(pendingRequests)){
-                if (req.type === 'subscription') {
-                    req.callbacks.complete();
-                } else if (!req.connection) {
-                    // close pending requests that aren't attached to a connection yet
-                    req.callbacks.error(TRPCClientError.TRPCClientError.from(new TRPCWebSocketClosedError({
-                        message: 'Closed before connection was established'
-                    })));
-                }
-            }
-            if (activeConnection) {
-                closeIfNoPending(activeConnection);
-            }
-            clearTimeout(connectTimer);
-            connectTimer = undefined;
-            activeConnection = null;
-        },
-        request,
-        get connection () {
-            return activeConnection;
-        },
-        /**
-     * Reconnect to the WebSocket server
-     */ reconnect,
-        connectionState: connectionState
-    };
-}
-class TRPCWebSocketClosedError extends Error {
-    constructor(opts){
-        super(opts?.message ?? 'WebSocket closed', // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore https://github.com/tc39/proposal-error-cause
-        {
-            cause: opts?.cause
-        });
-        this.name = 'TRPCWebSocketClosedError';
-        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
-    }
-}
-/**
- * @see https://trpc.io/docs/v11/client/links/wsLink
- * @deprecated
- * 🙋‍♂️ **Contributors needed** to continue supporting WebSockets!
- * See https://github.com/trpc/trpc/issues/6109
- */ function wsLink(opts) {
-    const transformer$1 = transformer.getTransformer(opts.transformer);
-    return ()=>{
-        const { client } = opts;
-        return ({ op })=>{
-            return observable.observable((observer)=>{
-                const { type, path, id, context } = op;
-                const input = transformer$1.input.serialize(op.input);
-                const connState = type === 'subscription' ? client.connectionState.subscribe({
-                    next (result) {
-                        observer.next({
-                            result,
-                            context
-                        });
-                    }
-                }) : null;
-                const unsubscribeRequest = client.request({
-                    op: {
-                        type,
-                        path,
-                        input,
-                        id,
-                        context,
-                        signal: null
-                    },
-                    callbacks: {
-                        error (err) {
-                            observer.error(err);
-                            unsubscribeRequest();
-                        },
-                        complete () {
-                            observer.complete();
-                        },
-                        next (event) {
-                            const transformed = unstableCoreDoNotImport.transformResult(event, transformer$1.output);
-                            if (!transformed.ok) {
-                                observer.error(TRPCClientError.TRPCClientError.from(transformed.error));
-                                return;
-                            }
-                            observer.next({
-                                result: transformed.result
-                            });
-                            if (op.type !== 'subscription') {
-                                // if it isn't a subscription we don't care about next response
-                                unsubscribeRequest();
-                                observer.complete();
-                            }
-                        }
-                    },
-                    lastEventId: undefined
-                });
-                return ()=>{
-                    unsubscribeRequest();
-                    connState?.unsubscribe();
-                };
-            });
-        };
-    };
-}
-
-exports.createWSClient = createWSClient;
-exports.wsLink = wsLink;