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

package/src/links/localLink.ts

@@ -0,0 +1,277 @@
+import {
+  getTRPCErrorFromUnknown,
+  getTRPCErrorShape,
+  isTrackedEnvelope,
+} from '@trpc/server';
+import { behaviorSubject, observable } from '@trpc/server/observable';
+import { TRPC_ERROR_CODES_BY_KEY, type TRPCResult } from '@trpc/server/rpc';
+import {
+  callProcedure,
+  isAbortError,
+  isAsyncIterable,
+  iteratorResource,
+  makeResource,
+  retryableRpcCodes,
+  run,
+  type AnyRouter,
+  type ErrorHandlerOptions,
+  type inferClientTypes,
+  type inferRouterContext,
+} from '@trpc/server/unstable-core-do-not-import';
+import { inputWithTrackedEventId } from '../internals/inputWithTrackedEventId';
+import { abortSignalToPromise, raceAbortSignals } from '../internals/signals';
+import { getTransformer } from '../internals/transformer';
+import type { TransformerOptions } from '../internals/transformer';
+import { isTRPCClientError, TRPCClientError } from '../TRPCClientError';
+import type { TRPCConnectionState } from './internals/subscriptions';
+import type { TRPCLink } from './types';
+
+export type LocalLinkOptions<TRouter extends AnyRouter> = {
+  router: TRouter;
+  createContext: () => Promise<inferRouterContext<TRouter>>;
+  onError?: (opts: ErrorHandlerOptions<inferRouterContext<TRouter>>) => void;
+} & TransformerOptions<inferClientTypes<TRouter>>;
+
+/**
+ * localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.
+ *
+ * @see https://trpc.io/docs/links/localLink
+ */
+export function experimental_localLink<TRouter extends AnyRouter>(
+  opts: LocalLinkOptions<TRouter>,
+): TRPCLink<TRouter> {
+  const transformer = getTransformer(opts.transformer);
+
+  const transformChunk = (chunk: unknown) => {
+    if (opts.transformer) {
+      // assume transformer will do the right thing
+      return chunk;
+    }
+    // Special case for undefined, because `JSON.stringify(undefined)` throws
+    if (chunk === undefined) {
+      return chunk;
+    }
+    const serialized = JSON.stringify(transformer.input.serialize(chunk));
+    const deserialized = JSON.parse(transformer.output.deserialize(serialized));
+    return deserialized;
+  };
+
+  return () =>
+    ({ op }) =>
+      observable((observer) => {
+        let ctx: inferRouterContext<TRouter> | undefined = undefined;
+        const ac = new AbortController();
+
+        const signal = raceAbortSignals(op.signal, ac.signal);
+        const signalPromise = abortSignalToPromise(signal);
+
+        signalPromise.catch(() => {
+          // prevent unhandled rejection
+        });
+
+        let input = op.input;
+        async function runProcedure(newInput: unknown): Promise<unknown> {
+          input = newInput;
+
+          ctx = await opts.createContext();
+
+          return callProcedure({
+            router: opts.router,
+            path: op.path,
+            getRawInput: async () => newInput,
+            ctx,
+            type: op.type,
+            signal,
+          });
+        }
+
+        function onErrorCallback(cause: unknown) {
+          if (isAbortError(cause)) {
+            return;
+          }
+          opts.onError?.({
+            error: getTRPCErrorFromUnknown(cause),
+            type: op.type,
+            path: op.path,
+            input,
+            ctx,
+          });
+        }
+
+        function coerceToTRPCClientError(cause: unknown) {
+          if (isTRPCClientError<TRouter>(cause)) {
+            return cause;
+          }
+          const error = getTRPCErrorFromUnknown(cause);
+
+          const shape = getTRPCErrorShape({
+            config: opts.router._def._config,
+            ctx,
+            error,
+            input,
+            path: op.path,
+            type: op.type,
+          });
+          return TRPCClientError.from({
+            error: transformChunk(shape),
+          });
+        }
+
+        run(async () => {
+          switch (op.type) {
+            case 'query':
+            case 'mutation': {
+              const result = await runProcedure(op.input);
+              if (!isAsyncIterable(result)) {
+                observer.next({
+                  result: { data: transformChunk(result) },
+                });
+                observer.complete();
+                break;
+              }
+
+              observer.next({
+                result: {
+                  data: (async function* () {
+                    await using iterator = iteratorResource(result);
+                    using _finally = makeResource({}, () => {
+                      observer.complete();
+                    });
+                    try {
+                      while (true) {
+                        const res = await Promise.race([
+                          iterator.next(),
+                          signalPromise,
+                        ]);
+                        if (res.done) {
+                          return transformChunk(res.value);
+                        }
+                        yield transformChunk(res.value);
+                      }
+                    } catch (cause) {
+                      onErrorCallback(cause);
+                      throw coerceToTRPCClientError(cause);
+                    }
+                  })(),
+                },
+              });
+              break;
+            }
+            case 'subscription': {
+              const connectionState = behaviorSubject<
+                TRPCConnectionState<TRPCClientError<any>>
+              >({
+                type: 'state',
+                state: 'connecting',
+                error: null,
+              });
+
+              const connectionSub = connectionState.subscribe({
+                next(state) {
+                  observer.next({
+                    result: state,
+                  });
+                },
+              });
+              let lastEventId: string | undefined = undefined;
+
+              using _finally = makeResource({}, async () => {
+                observer.complete();
+
+                connectionState.next({
+                  type: 'state',
+                  state: 'idle',
+                  error: null,
+                });
+                connectionSub.unsubscribe();
+              });
+              while (true) {
+                const result = await runProcedure(
+                  inputWithTrackedEventId(op.input, lastEventId),
+                );
+                if (!isAsyncIterable(result)) {
+                  throw new Error('Expected an async iterable');
+                }
+                await using iterator = iteratorResource(result);
+
+                observer.next({
+                  result: {
+                    type: 'started',
+                  },
+                });
+                connectionState.next({
+                  type: 'state',
+                  state: 'pending',
+                  error: null,
+                });
+
+                // Use a while loop to handle errors and reconnects
+                while (true) {
+                  let res;
+                  try {
+                    res = await Promise.race([iterator.next(), signalPromise]);
+                  } catch (cause) {
+                    if (isAbortError(cause)) {
+                      return;
+                    }
+                    const error = getTRPCErrorFromUnknown(cause);
+
+                    if (
+                      !retryableRpcCodes.includes(
+                        TRPC_ERROR_CODES_BY_KEY[error.code],
+                      )
+                    ) {
+                      throw coerceToTRPCClientError(error);
+                    }
+
+                    onErrorCallback(error);
+                    connectionState.next({
+                      type: 'state',
+                      state: 'connecting',
+                      error: coerceToTRPCClientError(error),
+                    });
+
+                    break;
+                  }
+
+                  if (res.done) {
+                    return;
+                  }
+                  let chunk: TRPCResult<unknown>;
+                  if (isTrackedEnvelope(res.value)) {
+                    lastEventId = res.value[0];
+
+                    chunk = {
+                      id: res.value[0],
+                      data: {
+                        id: res.value[0],
+                        data: res.value[1],
+                      },
+                    };
+                  } else {
+                    chunk = {
+                      data: res.value,
+                    };
+                  }
+
+                  observer.next({
+                    result: {
+                      ...chunk,
+                      data: transformChunk(chunk.data),
+                    },
+                  });
+                }
+              }
+              break;
+            }
+          }
+        }).catch((cause) => {
+          onErrorCallback(cause);
+          observer.error(coerceToTRPCClientError(cause));
+        });
+
+        return () => {
+          ac.abort();
+        };
+      });
+}

package/src/links/wsLink/wsClient/requestManager.ts

@@ -165,6 +165,15 @@ export class RequestManager {
     return this.getPendingRequests().length > 0;
   }
 
+  /**
+   * Checks if there are any pending subscriptions
+   */
+  public hasPendingSubscriptions() {
+    return this.getPendingRequests().some(
+      (request) => request.message.method === 'subscription',
+    );
+  }
+
   /**
    * Checks if there are any outgoing requests waiting to be sent.
    */

package/src/links/wsLink/wsClient/wsClient.ts

@@ -330,7 +330,7 @@ export class WsClient {
       handleCloseOrError(event);
       this.callbacks.onClose?.(event);
 
-      if (!this.lazyMode) {
+      if (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) {
         this.reconnect(
           new TRPCWebSocketClosedError({
             message: 'WebSocket closed',

package/src/links.ts

@@ -9,6 +9,7 @@ export * from './links/splitLink';
 export * from './links/wsLink/wsLink';
 export * from './links/httpSubscriptionLink';
 export * from './links/retryLink';
+export * from './links/localLink';
 
 // These are not public (yet) as we get this functionality from tanstack query
 // export * from './links/internals/dedupeLink';

package/unstable-internals/package.json

@@ -0,0 +1 @@
+{"main":"../dist/unstable-internals.js","module":"../dist/unstable-internals.mjs","types":"../dist/unstable-internals.d.ts"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AAExB,OAAO;AACL;;GAEG;AACH,gBAAgB,IAAI,qBAAqB;AACzC;;GAEG;AACH,KAAK,iBAAiB,IAAI,sBAAsB,GACjD,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/internals/dataLoader.d.ts

@@ -1,13 +0,0 @@
-export type BatchLoader<TKey, TValue> = {
-    validate: (keys: TKey[]) => boolean;
-    fetch: (keys: TKey[]) => Promise<TValue[] | Promise<TValue>[]>;
-};
-/**
- * Dataloader that's very inspired by https://github.com/graphql/dataloader
- * Less configuration, no caching, and allows you to cancel requests
- * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
- */
-export declare function dataLoader<TKey, TValue>(batchLoader: BatchLoader<TKey, TValue>): {
-    load: (key: TKey) => Promise<TValue>;
-};
-//# sourceMappingURL=dataLoader.d.ts.map

package/dist/internals/dataLoader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataLoader.d.ts","sourceRoot":"","sources":["../../src/internals/dataLoader.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI;IACtC,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,OAAO,CAAC;IACpC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;CAChE,CAAC;AAWF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EACrC,WAAW,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;gBAsGnB,IAAI,KAAG,OAAO,CAAC,MAAM,CAAC;EA6B1C"}

package/dist/internals/inputWithTrackedEventId.d.ts

@@ -1,2 +0,0 @@
-export declare function inputWithTrackedEventId(input: unknown, lastEventId: string | undefined): unknown;
-//# sourceMappingURL=inputWithTrackedEventId.d.ts.map

package/dist/internals/inputWithTrackedEventId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inputWithTrackedEventId.d.ts","sourceRoot":"","sources":["../../src/internals/inputWithTrackedEventId.ts"],"names":[],"mappings":"AAAA,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,WAYhC"}

package/dist/internals/signals.d.ts

@@ -1,15 +0,0 @@
-import type { Maybe } from '@trpc/server/unstable-core-do-not-import';
-/**
- * Like `Promise.all()` but for abort signals
- * - When all signals have been aborted, the merged signal will be aborted
- * - If one signal is `null`, no signal will be aborted
- */
-export declare function allAbortSignals(...signals: Maybe<AbortSignal>[]): AbortSignal;
-/**
- * Like `Promise.race` but for abort signals
- *
- * Basically, a ponyfill for
- * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
- */
-export declare function raceAbortSignals(...signals: Maybe<AbortSignal>[]): AbortSignal;
-//# sourceMappingURL=signals.d.ts.map

package/dist/internals/signals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../src/internals/signals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAEtE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,EAAE,GAAG,WAAW,CAwB7E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,EAAE,GAC/B,WAAW,CAYb"}

package/dist/links/internals/createChain.d.ts

@@ -1,8 +0,0 @@
-import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
-import type { Operation, OperationLink, OperationResultObservable } from '../types';
-/** @internal */
-export declare function createChain<TRouter extends AnyRouter, TInput = unknown, TOutput = unknown>(opts: {
-    links: OperationLink<TRouter, TInput, TOutput>[];
-    op: Operation<TInput>;
-}): OperationResultObservable<TRouter, TOutput>;
-//# sourceMappingURL=createChain.d.ts.map

package/dist/links/internals/createChain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createChain.d.ts","sourceRoot":"","sources":["../../../src/links/internals/createChain.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EACb,yBAAyB,EAC1B,MAAM,UAAU,CAAC;AAElB,gBAAgB;AAChB,wBAAgB,WAAW,CACzB,OAAO,SAAS,SAAS,EACzB,MAAM,GAAG,OAAO,EAChB,OAAO,GAAG,OAAO,EACjB,IAAI,EAAE;IACN,KAAK,EAAE,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACjD,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACvB,GAAG,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,CAuB9C"}

package/dist/links/internals/dedupeLink.d.ts

@@ -1,7 +0,0 @@
-import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
-import type { TRPCLink } from '../types';
-/**
- * @internal used for testing
- */
-export declare function dedupeLink<TRouter extends AnyRouter = AnyRouter>(): TRPCLink<TRouter>;
-//# sourceMappingURL=dedupeLink.d.ts.map

package/dist/links/internals/dedupeLink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dedupeLink.d.ts","sourceRoot":"","sources":["../../../src/links/internals/dedupeLink.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0CAA0C,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;GAEG;AACH,wBAAgB,UAAU,CACxB,OAAO,SAAS,SAAS,GAAG,SAAS,KAClC,QAAQ,CAAC,OAAO,CAAC,CA2CrB"}

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

@@ -1,102 +0,0 @@
-import type { AnyTRPCRouter, inferRouterError } from '@trpc/server';
-import type { Observer } from '@trpc/server/observable';
-import type { TRPCClientOutgoingMessage, TRPCResponseMessage } from '@trpc/server/unstable-core-do-not-import';
-import type { TRPCClientError } from '../../../TRPCClientError';
-export type TCallbacks = Observer<TRPCResponseMessage<unknown, inferRouterError<AnyTRPCRouter>>, TRPCClientError<AnyTRPCRouter>>;
-type MessageId = string;
-type MessageIdLike = string | number | null;
-/**
- * Represents a WebSocket request managed by the RequestManager.
- * Combines the network message, a utility promise (`end`) that mirrors the lifecycle
- * handled by `callbacks`, and a set of state monitoring callbacks.
- */
-interface Request {
-    message: TRPCClientOutgoingMessage;
-    end: Promise<void>;
-    callbacks: TCallbacks;
-}
-/**
- * Manages WebSocket requests, tracking their lifecycle and providing utility methods
- * for handling outgoing and pending requests.
- *
- * - **Outgoing requests**: Requests that are queued and waiting to be sent.
- * - **Pending requests**: Requests that have been sent and are in flight awaiting a response.
- *   For subscriptions, multiple responses may be received until the subscription is closed.
- */
-export declare class RequestManager {
-    /**
-     * Stores requests that are outgoing, meaning they are registered but not yet sent over the WebSocket.
-     */
-    private outgoingRequests;
-    /**
-     * 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.
-     */
-    private pendingRequests;
-    /**
-     * Registers a new request by adding it to the outgoing queue and setting up
-     * callbacks for lifecycle events such as completion or error.
-     *
-     * @param message - The outgoing message to be sent.
-     * @param callbacks - Callback functions to observe the request's state.
-     * @returns A cleanup function to manually remove the request.
-     */
-    register(message: TRPCClientOutgoingMessage, callbacks: TCallbacks): () => void;
-    /**
-     * Deletes a request from both the outgoing and pending collections, if it exists.
-     */
-    delete(messageId: MessageIdLike): void;
-    /**
-     * Moves all outgoing requests to the pending state and clears the outgoing queue.
-     *
-     * The caller is expected to handle the actual sending of the requests
-     * (e.g., sending them over the network) after this method is called.
-     *
-     * @returns The list of requests that were transitioned to the pending state.
-     */
-    flush(): (Request & {
-        id: MessageId;
-    })[];
-    /**
-     * Retrieves all currently pending requests, which are in flight awaiting responses
-     * or handling ongoing subscriptions.
-     */
-    getPendingRequests(): Request[];
-    /**
-     * Retrieves a specific pending request by its message ID.
-     */
-    getPendingRequest(messageId: MessageIdLike): Request | null | undefined;
-    /**
-     * Retrieves all outgoing requests, which are waiting to be sent.
-     */
-    getOutgoingRequests(): (Request & {
-        id: MessageId;
-    })[];
-    /**
-     * Retrieves all requests, both outgoing and pending, with their respective states.
-     *
-     * @returns An array of all requests with their state ("outgoing" or "pending").
-     */
-    getRequests(): ({
-        state: "outgoing";
-        message: TRPCClientOutgoingMessage;
-        end: Promise<void>;
-        callbacks: TCallbacks;
-    } | {
-        state: "pending";
-        message: TRPCClientOutgoingMessage;
-        end: Promise<void>;
-        callbacks: TCallbacks;
-    })[];
-    /**
-     * Checks if there are any pending requests, including ongoing subscriptions.
-     */
-    hasPendingRequests(): boolean;
-    /**
-     * Checks if there are any outgoing requests waiting to be sent.
-     */
-    hasOutgoingRequests(): boolean;
-}
-export {};
-//# sourceMappingURL=requestManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"requestManager.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/requestManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAGhE,MAAM,MAAM,UAAU,GAAG,QAAQ,CAC/B,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,CAAC,aAAa,CAAC,CAAC,EAC7D,eAAe,CAAC,aAAa,CAAC,CAC/B,CAAC;AAEF,KAAK,SAAS,GAAG,MAAM,CAAC;AACxB,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE5C;;;;GAIG;AACH,UAAU,OAAO;IACf,OAAO,EAAE,yBAAyB,CAAC;IACnC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,SAAS,EAAE,UAAU,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,OAAO,CAAC,gBAAgB,CAA4C;IAEpE;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAAkC;IAEzD;;;;;;;OAOG;IACI,QAAQ,CAAC,OAAO,EAAE,yBAAyB,EAAE,SAAS,EAAE,UAAU;IA2BzE;;OAEG;IACI,MAAM,CAAC,SAAS,EAAE,aAAa;IAStC;;;;;;;OAOG;IACI,KAAK;YAhEyC,SAAS;;IA0E9D;;;OAGG;IACI,kBAAkB;IAIzB;;OAEG;IACI,iBAAiB,CAAC,SAAS,EAAE,aAAa;IAMjD;;OAEG;IACI,mBAAmB;YA9F2B,SAAS;;IAkG9D;;;;OAIG;IACI,WAAW;;;;;;;;;;;IAiBlB;;OAEG;IACI,kBAAkB;IAIzB;;OAEG;IACI,mBAAmB;CAG3B"}

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

@@ -1,38 +0,0 @@
-import type { TRPCRequestInfo } from '@trpc/server/unstable-core-do-not-import';
-import type { CallbackOrValue, UrlOptionsWithConnectionParams } from '../../internals/urlWithConnectionParams';
-export declare class TRPCWebSocketClosedError extends Error {
-    constructor(opts: {
-        message: string;
-        cause?: unknown;
-    });
-}
-/**
- * Utility class for managing a timeout that can be started, stopped, and reset.
- * Useful for scenarios where the timeout duration is reset dynamically based on events.
- */
-export declare class ResettableTimeout {
-    private readonly onTimeout;
-    private readonly timeoutMs;
-    private timeout;
-    constructor(onTimeout: () => void, timeoutMs: number);
-    /**
-     * Resets the current timeout, restarting it with the same duration.
-     * Does nothing if no timeout is active.
-     */
-    reset(): void;
-    start(): void;
-    stop(): void;
-}
-export declare function withResolvers<T>(): {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-};
-/**
- * Resolves a WebSocket URL and optionally appends connection parameters.
- *
- * If connectionParams are provided, appends 'connectionParams=1' query parameter.
- */
-export declare function prepareUrl(urlOptions: UrlOptionsWithConnectionParams): Promise<string>;
-export declare function buildConnectionMessage(connectionParams: CallbackOrValue<TRPCRequestInfo['connectionParams']>): Promise<string>;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EAChB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,eAAe,EACf,8BAA8B,EAC/B,MAAM,yCAAyC,CAAC;AAGjD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAOvD;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,OAAO,CAA4C;gBAGxC,SAAS,EAAE,MAAM,IAAI,EACrB,SAAS,EAAE,MAAM;IAGpC;;;OAGG;IACI,KAAK;IAOL,KAAK;IAKL,IAAI;CAIZ;AAGD,wBAAgB,aAAa,CAAC,CAAC;;qBACR,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;sBAC1B,GAAG,KAAK,IAAI;EAQnC;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,8BAA8B,mBAU1E;AAED,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,eAAe,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,mBAQvE"}

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

@@ -1,79 +0,0 @@
-import type { UrlOptionsWithConnectionParams } from '../../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

@@ -1 +0,0 @@
-{"version":3,"file":"wsConnection.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/wsConnection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAoB9F,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;IAQ1C;;OAEG;IACI,QAAQ,IAAI,IAAI,IAAI;QAAE,EAAE,EAAE,SAAS,CAAA;KAAE;IAQ5C;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW,CAA8B;IACpC,IAAI;IAyCjB;;;OAGG;IACU,KAAK;CAOnB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,YAAY;;;;;;;;;;;;SA0B7D"}

package/dist/links.d.ts

@@ -1,11 +0,0 @@
-export * from './links/types';
-export * from './links/HTTPBatchLinkOptions';
-export * from './links/httpBatchLink';
-export * from './links/httpBatchStreamLink';
-export * from './links/httpLink';
-export * from './links/loggerLink';
-export * from './links/splitLink';
-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 +0,0 @@
-{"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/dist/unstable-internals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unstable-internals.d.ts","sourceRoot":"","sources":["../src/unstable-internals.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC"}