@trpc/react-query 11.0.0-alpha-tmp-subscription-connection-state.488 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/shared/hooks/createHooksInternal.mjs

@@ -1,14 +1,13 @@
-import { useQuery, useSuspenseQuery, useQueryClient, useMutation, skipToken, hashKey, useInfiniteQuery, useSuspenseInfiniteQuery, useQueries, useSuspenseQueries } from '@tanstack/react-query';
+import { useQuery, usePrefetchQuery, useSuspenseQuery, useMutation, skipToken, hashKey, useInfiniteQuery, usePrefetchInfiniteQuery, useSuspenseInfiniteQuery, useQueries, useSuspenseQueries } from '@tanstack/react-query';
 import { createTRPCUntypedClient } from '@trpc/client';
 import { isAsyncIterable } from '@trpc/server/unstable-core-do-not-import';
 import * as React from 'react';
 import { TRPCContext } from '../../internals/context.mjs';
 import { getClientArgs } from '../../internals/getClientArgs.mjs';
 import { getQueryKeyInternal, getMutationKeyInternal } from '../../internals/getQueryKey.mjs';
-import { useHookResult } from '../../internals/useHookResult.mjs';
+import { buildQueryFromAsyncIterable, useHookResult } from '../../internals/trpcResult.mjs';
 import { createUtilityFunctions } from '../../utils/createUtilityFunctions.mjs';
 import { createUseQueries } from '../proxy/useQueriesProxy.mjs';
-import { getStartingResult, getIdleResult, getPendingResult, getConnectingResult, getErrorResult } from './types.mjs';
 
 const trackResult = (result, onTrackResult)=>{
     const trackedResult = new Proxy(result, {
@@ -28,7 +27,7 @@ const trackResult = (result, onTrackResult)=>{
         return createTRPCUntypedClient(opts);
     };
     const TRPCProvider = (props)=>{
-        const { abortOnUnmount =false , client , queryClient , ssrContext  } = props;
+        const { abortOnUnmount = false, client, queryClient, ssrContext } = props;
         const [ssrState, setSSRState] = React.useState(props.ssrState ?? false);
         const fns = React.useMemo(()=>createUtilityFunctions({
                 client,
@@ -70,9 +69,9 @@ const trackResult = (result, onTrackResult)=>{
     }
     /**
    * Hack to make sure errors return `status`='error` when doing SSR
-   * @link https://github.com/trpc/trpc/pull/1645
+   * @see https://github.com/trpc/trpc/pull/1645
    */ function useSSRQueryOptionsIfNeeded(queryKey, opts) {
-        const { queryClient , ssrState  } = useContext();
+        const { queryClient, ssrState } = useContext();
         return ssrState && ssrState !== 'mounted' && queryClient.getQueryCache().find({
             queryKey
         })?.state.status === 'error' ? {
@@ -82,7 +81,7 @@ const trackResult = (result, onTrackResult)=>{
     }
     function useQuery$1(path, input, opts) {
         const context = useContext();
-        const { abortOnUnmount , client , ssrState , queryClient , prefetchQuery  } = context;
+        const { abortOnUnmount, client, ssrState, queryClient, prefetchQuery } = context;
         const queryKey = getQueryKeyInternal(path, input, 'query');
         const defaultOpts = queryClient.getQueryDefaults(queryKey);
         const isInputSkipToken = input === skipToken;
@@ -113,24 +112,7 @@ const trackResult = (result, onTrackResult)=>{
                 };
                 const result = await client.query(...getClientArgs(queryKey, actualOpts));
                 if (isAsyncIterable(result)) {
-                    const queryCache = queryClient.getQueryCache();
-                    const query = queryCache.build(queryFunctionContext.queryKey, {
-                        queryKey
-                    });
-                    query.setState({
-                        data: [],
-                        status: 'success'
-                    });
-                    const aggregate = [];
-                    for await (const value of result){
-                        aggregate.push(value);
-                        query.setState({
-                            data: [
-                                ...aggregate
-                            ]
-                        });
-                    }
-                    return aggregate;
+                    return buildQueryFromAsyncIterable(result, queryClient, queryKey);
                 }
                 return result;
             }
@@ -140,6 +122,27 @@ const trackResult = (result, onTrackResult)=>{
         });
         return hook;
     }
+    function usePrefetchQuery$1(path, input, opts) {
+        const context = useContext();
+        const queryKey = getQueryKeyInternal(path, input, 'query');
+        const isInputSkipToken = input === skipToken;
+        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? context.abortOnUnmount;
+        usePrefetchQuery({
+            ...opts,
+            queryKey: queryKey,
+            queryFn: isInputSkipToken ? input : (queryFunctionContext)=>{
+                const actualOpts = {
+                    trpc: {
+                        ...opts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                return context.client.query(...getClientArgs(queryKey, actualOpts));
+            }
+        });
+    }
     function useSuspenseQuery$1(path, input, opts) {
         const context = useContext();
         const queryKey = getQueryKeyInternal(path, input, 'query');
@@ -149,7 +152,9 @@ const trackResult = (result, onTrackResult)=>{
             queryKey: queryKey,
             queryFn: (queryFunctionContext)=>{
                 const actualOpts = {
+                    ...opts,
                     trpc: {
+                        ...opts?.trpc,
                         ...shouldAbortOnUnmount ? {
                             signal: queryFunctionContext.signal
                         } : {
@@ -169,8 +174,7 @@ const trackResult = (result, onTrackResult)=>{
         ];
     }
     function useMutation$1(path, opts) {
-        const { client  } = useContext();
-        const queryClient = useQueryClient();
+        const { client, queryClient } = useContext();
         const mutationKey = getMutationKeyInternal(path);
         const defaultOpts = queryClient.defaultMutationOptions(queryClient.getMutationDefaults(mutationKey));
         const hook = useMutation({
@@ -201,37 +205,18 @@ const trackResult = (result, onTrackResult)=>{
     /* istanbul ignore next -- @preserve */ function useSubscription(path, input, opts) {
         const enabled = opts?.enabled ?? input !== skipToken;
         const queryKey = hashKey(getQueryKeyInternal(path, input, 'any'));
+        const { client } = useContext();
+        const optsRef = React.useRef(opts);
+        optsRef.current = opts;
         const trackedProps = React.useRef(new Set([]));
         const addTrackedProp = React.useCallback((key)=>{
             trackedProps.current.add(key);
         }, []);
-        // const restart = React.useRef<restartSubscriptionFn<unknown>>(() => {
-        //   throw new Error('not implemented');
-        // });
-        const currentResult = React.useRef(enabled ? getStartingResult() : getIdleResult());
-        const [subscriptionState, setSubscriptionState] = React.useState(trackResult(currentResult.current, addTrackedProp));
-        const updateSubscriptionState = React.useCallback((opts)=>{
-            const oldResult = currentResult.current;
-            const newResult = typeof opts === 'function' ? opts(currentResult.current) : opts;
-            currentResult.current = newResult;
-            let shouldUpdate = false;
-            for (const key of trackedProps.current){
-                if (oldResult[key] !== newResult[key]) {
-                    shouldUpdate = true;
-                    break;
-                }
-            }
-            if (shouldUpdate) {
-                setSubscriptionState(trackResult(newResult, addTrackedProp));
-                return;
-            }
-        }, [
-            addTrackedProp
-        ]);
-        const { client  } = useContext();
-        const optsRef = React.useRef(opts);
-        optsRef.current = opts;
-        React.useEffect(()=>{
+        const currentSubscriptionRef = React.useRef(null);
+        const reset = React.useCallback(()=>{
+            // unsubscribe from the previous subscription
+            currentSubscriptionRef.current?.();
+            updateState(getInitialState);
             if (!enabled) {
                 return;
             }
@@ -240,60 +225,107 @@ const trackResult = (result, onTrackResult)=>{
                 onStarted: ()=>{
                     if (!isStopped) {
                         optsRef.current.onStarted?.();
+                        updateState((prev)=>({
+                                ...prev,
+                                status: 'pending',
+                                error: null
+                            }));
                     }
                 },
                 onData: (data)=>{
                     if (!isStopped) {
-                        optsRef.current.onData(data);
-                        updateSubscriptionState((prev)=>{
-                            if (prev.isPending) {
-                                return getPendingResult(prev, data);
-                            }
-                            return prev;
-                        });
+                        optsRef.current.onData?.(data);
+                        updateState((prev)=>({
+                                ...prev,
+                                status: 'pending',
+                                data,
+                                error: null
+                            }));
                     }
                 },
-                onError: (err)=>{
+                onError: (error)=>{
                     if (!isStopped) {
-                        optsRef.current.onError?.(err);
+                        optsRef.current.onError?.(error);
+                        updateState((prev)=>({
+                                ...prev,
+                                status: 'error',
+                                error
+                            }));
                     }
                 },
-                onStateChange: (state)=>{
-                    if (state.state === 'idle') {
-                        updateSubscriptionState(getIdleResult());
-                        return;
-                    }
-                    if (state.state === 'connecting') {
-                        updateSubscriptionState((prev)=>{
-                            return getConnectingResult(prev, state.data ?? null);
-                        });
-                        return;
-                    }
-                    if (state.state === 'pending') {
-                        updateSubscriptionState((prev)=>getPendingResult(prev));
-                    }
-                    if (state.state === 'error') {
-                        updateSubscriptionState((prev)=>{
-                            return getErrorResult(prev, state.data);
-                        });
-                    }
+                onConnectionStateChange: (result)=>{
+                    const delta = {
+                        status: result.state,
+                        error: result.error
+                    };
+                    updateState((prev)=>{
+                        return {
+                            ...prev,
+                            ...delta
+                        };
+                    });
                 }
             });
-            // const effectRestart = restart.current;
-            return ()=>{
+            currentSubscriptionRef.current = ()=>{
                 isStopped = true;
                 subscription.unsubscribe();
-                updateSubscriptionState(getIdleResult());
             };
         // eslint-disable-next-line react-hooks/exhaustive-deps
         }, [
             queryKey,
             enabled
         ]);
-        return subscriptionState;
+        const getInitialState = React.useCallback(()=>{
+            return enabled ? {
+                data: undefined,
+                error: null,
+                status: 'connecting',
+                reset
+            } : {
+                data: undefined,
+                error: null,
+                status: 'idle',
+                reset
+            };
+        }, [
+            enabled,
+            reset
+        ]);
+        const resultRef = React.useRef(getInitialState());
+        const [state, setState] = React.useState(trackResult(resultRef.current, addTrackedProp));
+        state.reset = reset;
+        const updateState = React.useCallback((callback)=>{
+            const prev = resultRef.current;
+            const next = resultRef.current = callback(prev);
+            let shouldUpdate = false;
+            for (const key of trackedProps.current){
+                if (prev[key] !== next[key]) {
+                    shouldUpdate = true;
+                    break;
+                }
+            }
+            if (shouldUpdate) {
+                setState(trackResult(next, addTrackedProp));
+            }
+        }, [
+            addTrackedProp
+        ]);
+        React.useEffect(()=>{
+            if (!enabled) {
+                return;
+            }
+            reset();
+            return ()=>{
+                currentSubscriptionRef.current?.();
+            };
+        }, [
+            reset,
+            enabled
+        ]);
+        return state;
     }
     function useInfiniteQuery$1(path, input, opts) {
-        const { client , ssrState , prefetchInfiniteQuery , queryClient , abortOnUnmount ,  } = useContext();
+        const { client, ssrState, prefetchInfiniteQuery, queryClient, abortOnUnmount } = useContext();
         const queryKey = getQueryKeyInternal(path, input, 'infinite');
         const defaultOpts = queryClient.getQueryDefaults(queryKey);
         const isInputSkipToken = input === skipToken;
@@ -339,6 +371,38 @@ const trackResult = (result, onTrackResult)=>{
         });
         return hook;
     }
+    function usePrefetchInfiniteQuery$1(path, input, opts) {
+        const context = useContext();
+        const queryKey = getQueryKeyInternal(path, input, 'infinite');
+        const defaultOpts = context.queryClient.getQueryDefaults(queryKey);
+        const isInputSkipToken = input === skipToken;
+        const ssrOpts = useSSRQueryOptionsIfNeeded(queryKey, {
+            ...defaultOpts,
+            ...opts
+        });
+        // request option should take priority over global
+        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? context.abortOnUnmount;
+        usePrefetchInfiniteQuery({
+            ...opts,
+            initialPageParam: opts.initialCursor ?? null,
+            queryKey,
+            queryFn: isInputSkipToken ? input : (queryFunctionContext)=>{
+                const actualOpts = {
+                    ...ssrOpts,
+                    trpc: {
+                        ...ssrOpts?.trpc,
+                        ...shouldAbortOnUnmount ? {
+                            signal: queryFunctionContext.signal
+                        } : {}
+                    }
+                };
+                return context.client.query(...getClientArgs(queryKey, actualOpts, {
+                    pageParam: queryFunctionContext.pageParam ?? opts.initialCursor,
+                    direction: queryFunctionContext.direction
+                }));
+            }
+        });
+    }
     function useSuspenseInfiniteQuery$1(path, input, opts) {
         const context = useContext();
         const queryKey = getQueryKeyInternal(path, input, 'infinite');
@@ -379,7 +443,7 @@ const trackResult = (result, onTrackResult)=>{
         ];
     }
     const useQueries$1 = (queriesCallback)=>{
-        const { ssrState , queryClient , prefetchQuery , client  } = useContext();
+        const { ssrState, queryClient, prefetchQuery, client } = useContext();
         const proxy = createUseQueries(client);
         const queries = queriesCallback(proxy);
         if (typeof window === 'undefined' && ssrState === 'prepass') {
@@ -400,12 +464,13 @@ const trackResult = (result, onTrackResult)=>{
         }, queryClient);
     };
     const useSuspenseQueries$1 = (queriesCallback)=>{
-        const { queryClient , client  } = useContext();
+        const { queryClient, client } = useContext();
         const proxy = createUseQueries(client);
         const queries = queriesCallback(proxy);
         const hook = useSuspenseQueries({
             queries: queries.map((query)=>({
                     ...query,
+                    queryFn: query.queryFn,
                     queryKey: query.queryKey
                 }))
         }, queryClient);
@@ -420,12 +485,14 @@ const trackResult = (result, onTrackResult)=>{
         useContext,
         useUtils: useContext,
         useQuery: useQuery$1,
+        usePrefetchQuery: usePrefetchQuery$1,
         useSuspenseQuery: useSuspenseQuery$1,
         useQueries: useQueries$1,
         useSuspenseQueries: useSuspenseQueries$1,
         useMutation: useMutation$1,
         useSubscription,
         useInfiniteQuery: useInfiniteQuery$1,
+        usePrefetchInfiniteQuery: usePrefetchInfiniteQuery$1,
         useSuspenseInfiniteQuery: useSuspenseInfiniteQuery$1
     };
 }

package/dist/shared/hooks/types.d.ts

@@ -1,7 +1,7 @@
-import type { DefinedUseQueryResult, DehydratedState, InfiniteData, InfiniteQueryObserverSuccessResult, InitialDataFunction, QueryObserverSuccessResult, QueryOptions, UseBaseQueryOptions, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from '@tanstack/react-query';
-import type { ConnectionState, CreateTRPCClientOptions, TRPCConnectionStateMessage, TRPCRequestOptions, TRPCUntypedClient } from '@trpc/client';
+import type { DefinedUseQueryResult, DehydratedState, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, InfiniteQueryObserverSuccessResult, InitialDataFunction, QueryObserverSuccessResult, QueryOptions, UseBaseQueryOptions, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from '@tanstack/react-query';
+import type { CreateTRPCClientOptions, TRPCRequestOptions, TRPCUntypedClient } from '@trpc/client';
 import type { AnyRouter, DistributiveOmit } from '@trpc/server/unstable-core-do-not-import';
-import type { ReactNode } from 'react';
+import type { JSX, ReactNode } from 'react';
 import type { TRPCContextProps } from '../../internals/context';
 import type { TRPCQueryKey } from '../../internals/getQueryKey';
 export type OutputWithCursor<TData, TCursor = any> = {
@@ -28,6 +28,8 @@ export interface UseTRPCQueryOptions<TOutput, TData, TError, TQueryOptsData = TO
 }
 export interface UseTRPCSuspenseQueryOptions<TOutput, TData, TError> extends DistributiveOmit<UseSuspenseQueryOptions<TOutput, TError, TData, any>, 'queryKey'>, TRPCUseQueryBaseOptions {
 }
+export interface UseTRPCPrefetchQueryOptions<TOutput, TData, TError> extends DistributiveOmit<FetchQueryOptions<TOutput, TError, TData, any>, 'queryKey'>, TRPCUseQueryBaseOptions {
+}
 /** @internal **/
 export interface DefinedUseTRPCQueryOptions<TOutput, TData, TError, TQueryOptsData = TOutput> extends DistributiveOmit<UseTRPCQueryOptions<TOutput, TData, TError, TQueryOptsData>, 'queryKey'> {
     initialData: InitialDataFunction<TQueryOptsData> | TQueryOptsData;
@@ -41,193 +43,71 @@ export type ExtractCursorType<TInput> = TInput extends {
 export interface UseTRPCInfiniteQueryOptions<TInput, TOutput, TError> extends DistributiveOmit<UseInfiniteQueryOptions<TOutput, TError, TOutput, TOutput, any, ExtractCursorType<TInput>>, 'queryKey' | 'initialPageParam'>, TRPCUseQueryBaseOptions {
     initialCursor?: ExtractCursorType<TInput>;
 }
+export type UseTRPCPrefetchInfiniteQueryOptions<TInput, TOutput, TError> = DistributiveOmit<FetchInfiniteQueryOptions<TOutput, TError, TOutput, any, ExtractCursorType<TInput>>, 'queryKey' | 'initialPageParam'> & TRPCUseQueryBaseOptions & {
+    initialCursor?: ExtractCursorType<TInput>;
+};
 export interface UseTRPCSuspenseInfiniteQueryOptions<TInput, TOutput, TError> extends DistributiveOmit<UseSuspenseInfiniteQueryOptions<TOutput, TError, TOutput, TOutput, any, ExtractCursorType<TInput>>, 'queryKey' | 'initialPageParam'>, TRPCUseQueryBaseOptions {
     initialCursor?: ExtractCursorType<TInput>;
 }
 export interface UseTRPCMutationOptions<TInput, TError, TOutput, TContext = unknown> extends UseMutationOptions<TOutput, TError, TInput, TContext>, TRPCUseQueryBaseOptions {
 }
 export interface UseTRPCSubscriptionOptions<TOutput, TError> {
-    enabled?: boolean;
-    onStarted?: () => void;
     /**
-     * @deprecated use onStateChange instead
+     * @deprecated
+     * use a `skipToken` from `@tanstack/react-query` instead
+     * this will be removed in v12
      */
-    onError?: (err: TError) => void;
-    onData: (data: TOutput) => void;
-    onStateChange?: (state: TRPCConnectionStateMessage<TError>) => void;
-}
-export interface restartSubscriptionOptionsBase {
-    /**
-     * Cancel the current subscription and re-establish a new one
-     * - Defaults to `true`
-     * - Set to `false` no new subscription will be established if there is already an active subscription
-     */
-    cancelSubscription?: boolean;
-}
-export interface restartSubscriptionOptionsWithLastEventId extends restartSubscriptionOptionsBase {
-    /**
-     * Defaults to `true` in case of failure or if the subscription is still active
-     * - When the susbscription has successfully completed, it will be set to `false`
-     */
-    sendLastEventId?: boolean;
-}
-export type restartSubscriptionOptions<TInput> = TInput extends {
-    lastEventId?: string | null;
-} | void ? restartSubscriptionOptionsWithLastEventId : restartSubscriptionOptionsBase;
-export type restartSubscriptionFn<TInput> = (options?: restartSubscriptionOptions<TInput>) => void;
-export interface TRPCSubscriptionBaseResult<_TInput, TOutput, TError> {
-    /**
-     * The last data received from the subscription
-     */
-    data: TOutput | null;
-    /**
-     * The timestamp for when the connection was last (re-)established
-     */
-    connectionStartedAt: number;
-    /**
-     * The timestamp for when the connection was initially established
-     */
-    initialConnectionStartedAt: number;
-    /**
-     * The error that caused the subscription to stop
-     * - Defaults to `null`
-     * - Resets to `null` after the subscription is restarted and the connection is re-established
-     */
-    error: TError | null;
-    /**
-     * The timestamp for when the last error was captured
-     */
-    errorUpdatedAt: number;
-    /**
-     * The reason for the reconnection
-     * - Resets to `null` after the subscription is restarted and the connection is re-established
-     */
-    connectionError: TError | null;
-    /**
-     * Reconnection attempts since last successful connection
-     */
-    connectionAttemptCount: number;
-    /**
-     * The timestamp for when the last reconnection error was captured
-     */
-    connectionErrorUpdatedAt: number;
-    /**
-     * Is `true` when the subscription is establishing the initial connection
-     */
-    isStarting: boolean;
-    /**
-     * Is `true` when the subscription has successfully connected at least once
-     */
-    isStarted: boolean;
-    /**
-     * Is `true` if the subscription is (re-)establishing a connection
-     * - Alias for `status === 'connecting'`
-     */
-    isConnecting: boolean;
+    enabled?: boolean;
     /**
-     * Is `true` when the subscription is connected and listening for data
-     * - Alias for `status === 'pending'`
+     * Called when the subscription is started
      */
-    isPending: boolean;
+    onStarted?: () => void;
     /**
-     * Is `true` if the subscription is re-establishing a connection
-     * - Alias for `status === 'connecting' && isStarted === true`
+     * Called when new data is received
      */
-    isReconnecting: boolean;
+    onData?: (data: TOutput) => void;
     /**
-     * Is `true` if the subscription ended in an error state
-     * - Alias for `status === 'error'`
+     * Called when an **unrecoverable error** occurs and the subscription is closed
      */
-    isError: boolean;
+    onError?: (err: TError) => void;
+}
+export interface TRPCSubscriptionBaseResult<TOutput, TError> {
+    status: 'idle' | 'connecting' | 'pending' | 'error';
+    data: undefined | TOutput;
+    error: null | TError;
     /**
-     * The current state of the subscription
-     * - Will be:
-     *  - `'idle'` when the subscription is not enabled
-     *  - `'connecting'` when the subscription is (re-)establishing the connection
-     *  - `'pending'` when the subscription is connected and receiving data
-     *  - `'error'` when the subscription has stopped due to an error
+     * Reset the subscription
      */
-    status: ConnectionState;
+    reset: () => void;
 }
-export interface TRPCSubscriptionIdleResult<TInput, TOutput, TError> extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-    data: null;
-    error: null;
-    errorUpdatedAt: 0;
-    connectionError: null;
-    isStarting: false;
-    isStarted: false;
-    isConnecting: false;
-    isPending: false;
-    isReconnecting: false;
-    isError: false;
-    connectionAttemptCount: 0;
-    connectionErrorUpdatedAt: 0;
-    connectionStartedAt: 0;
-    initialConnectionStartedAt: 0;
+export interface TRPCSubscriptionIdleResult<TOutput> extends TRPCSubscriptionBaseResult<TOutput, null> {
     status: 'idle';
-}
-export declare const getIdleResult: <TInput, TOutput, TError>() => TRPCSubscriptionIdleResult<TInput, TOutput, TError>;
-export interface TRPCSubscriptionStartingResult<TInput, TOutput, TError> extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-    connectionStartedAt: 0;
-    initialConnectionStartedAt: 0;
+    data: undefined;
     error: null;
-    data: null;
-    connectionError: TError | null;
-    isStarting: true;
-    isStarted: false;
-    isConnecting: true;
-    isPending: false;
-    isReconnecting: false;
-    isError: false;
+}
+export interface TRPCSubscriptionConnectingResult<TOutput, TError> extends TRPCSubscriptionBaseResult<TOutput, TError> {
     status: 'connecting';
+    data: undefined | TOutput;
+    error: TError | null;
 }
-export declare const getStartingResult: <TInput, TOutput, TError>(previous?: TRPCSubscriptionIdleResult<TInput, TOutput, TError> | TRPCSubscriptionErrorResult<TInput, TOutput, TError> | TRPCSubscriptionStartingResult<TInput, TOutput, TError>, error?: TError | null) => TRPCSubscriptionStartingResult<TInput, TOutput, TError>;
-export interface TRPCSubscriptionPendingResult<TInput, TOutput, TError> extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-    error: null;
-    connectionError: null;
-    connectionAttemptCount: 0;
-    isStarting: false;
-    isStarted: true;
-    isConnecting: false;
-    isPending: true;
-    isReconnecting: false;
-    isError: false;
+export interface TRPCSubscriptionPendingResult<TOutput> extends TRPCSubscriptionBaseResult<TOutput, undefined> {
     status: 'pending';
-}
-export declare const getPendingResult: <TInput, TOutput, TError>(previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>, data?: TOutput) => TRPCSubscriptionPendingResult<TInput, TOutput, TError>;
-export interface TRPCSubscriptionReconnectingResult<TInput, TOutput, TError> extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
+    data: TOutput;
     error: null;
-    connectionError: TError;
-    isStarting: false;
-    isStarted: true;
-    isConnecting: true;
-    isPending: false;
-    isReconnecting: true;
-    isError: false;
-    status: 'connecting';
 }
-export declare const getReconnectingResult: <TInput, TOutput, TError>(previous: TRPCSubscriptionPendingResult<TInput, TOutput, TError> | TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>, error: TError) => TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>;
-export declare const getConnectingResult: <TInput, TOutput, TError>(previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>, error: TError | null) => TRPCSubscriptionConnectingResult<TInput, TOutput, TError>;
-export interface TRPCSubscriptionErrorResult<TInput, TOutput, TError> extends TRPCSubscriptionBaseResult<TInput, TOutput, TError> {
-    error: TError;
-    isStarting: false;
-    isStarted: true;
-    isConnecting: false;
-    isPending: false;
-    isReconnecting: false;
-    isError: true;
+export interface TRPCSubscriptionErrorResult<TOutput, TError> extends TRPCSubscriptionBaseResult<TOutput, TError> {
     status: 'error';
+    data: TOutput | undefined;
+    error: TError;
 }
-export declare const getErrorResult: <TInput, TOutput, TError>(previous: UseTRPCSubscriptionResult<TInput, TOutput, TError>, error: TError) => TRPCSubscriptionErrorResult<TInput, TOutput, TError>;
-export type TRPCSubscriptionConnectingResult<TInput, TOutput, TError> = TRPCSubscriptionStartingResult<TInput, TOutput, TError> | TRPCSubscriptionReconnectingResult<TInput, TOutput, TError>;
-export type UseTRPCSubscriptionResult<TInput, TOutput, TError> = TRPCSubscriptionIdleResult<TInput, TOutput, TError> | TRPCSubscriptionPendingResult<TInput, TOutput, TError> | TRPCSubscriptionConnectingResult<TInput, TOutput, TError> | TRPCSubscriptionErrorResult<TInput, TOutput, TError>;
+export type TRPCSubscriptionResult<TOutput, TError> = TRPCSubscriptionIdleResult<TOutput> | TRPCSubscriptionConnectingResult<TOutput, TError> | TRPCSubscriptionErrorResult<TOutput, TError> | TRPCSubscriptionPendingResult<TOutput>;
 export interface TRPCProviderProps<TRouter extends AnyRouter, TSSRContext> extends TRPCContextProps<TRouter, TSSRContext> {
     children: ReactNode;
 }
 export type TRPCProvider<TRouter extends AnyRouter, TSSRContext> = (props: TRPCProviderProps<TRouter, TSSRContext>) => JSX.Element;
 export type UseDehydratedState<TRouter extends AnyRouter> = (client: TRPCUntypedClient<TRouter>, trpcState: DehydratedState | undefined) => DehydratedState | undefined;
 export type CreateClient<TRouter extends AnyRouter> = (opts: CreateTRPCClientOptions<TRouter>) => TRPCUntypedClient<TRouter>;
-type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<infer $Inferred> ? $Inferred[] : TValue;
+export type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<infer $Inferred> ? $Inferred[] : TValue;
 /**
  * @internal
  */
@@ -271,5 +151,4 @@ export interface TRPCHookResult {
         path: string;
     };
 }
-export {};
 //# sourceMappingURL=types.d.ts.map