@trpc/react-query 11.0.0-alpha-tmp-react-sideeffects-import.202 → 11.0.0-alpha-tmp-ahmed-rollup-v4.203

package/dist/{createHooksInternal-e0b0564e.mjs → shared/hooks/createHooksInternal.mjs}

@@ -1,162 +1,12 @@
-import { createRecursiveProxy } from '@trpc/core';
 import { useQuery, useSuspenseQuery, useQueryClient, useMutation, hashKey, useInfiniteQuery, useSuspenseInfiniteQuery, useQueries, useSuspenseQueries } from '@tanstack/react-query';
-import { TRPCUntypedClient, getUntypedClient, createTRPCUntypedClient } from '@trpc/client';
-import * as React from 'react';
-import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601f.mjs';
-
-/**
- * Create proxy for decorating procedures
- * @internal
- */ function createReactDecoration(name, hooks) {
-    return createRecursiveProxy(({ path , args  })=>{
-        const pathCopy = [
-            name,
-            ...path
-        ];
-        // The last arg is for instance `.useMutation` or `.useQuery()`
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const lastArg = pathCopy.pop();
-        if (lastArg === 'useMutation') {
-            return hooks[lastArg](pathCopy, ...args);
-        }
-        if (lastArg === '_def') {
-            return {
-                path: pathCopy
-            };
-        }
-        const [input, ...rest] = args;
-        const opts = rest[0] || {};
-        return hooks[lastArg](pathCopy, input, opts);
-    });
-}
-
-/**
- * Create proxy for `useQueries` options
- * @internal
- */ function createUseQueries(client) {
-    return createRecursiveProxy((opts)=>{
-        const arrayPath = opts.path;
-        const dotPath = arrayPath.join('.');
-        const [input, _opts] = opts.args;
-        const options = {
-            queryKey: getQueryKeyInternal(arrayPath, input, 'query'),
-            queryFn: ()=>{
-                return client.query(dotPath, input, _opts?.trpc);
-            },
-            ..._opts
-        };
-        return options;
-    });
-}
-
-/**
- * @internal
- */ function getClientArgs(queryKey, opts, pageParam) {
-    const path = queryKey[0];
-    const input = queryKey[1]?.input;
-    if (pageParam) input.cursor = pageParam;
-    return [
-        path.join('.'),
-        input,
-        opts?.trpc
-    ];
-}
-
-/**
- * Makes a stable reference of the `trpc` prop
- */ function useHookResult(value) {
-    const ref = React.useRef(value);
-    ref.current.path = value.path;
-    return ref.current;
-}
-
-/**
- * Creates a set of utility functions that can be used to interact with `react-query`
- * @param opts the `TRPCClient` and `QueryClient` to use
- * @returns a set of utility functions that can be used to interact with `react-query`
- * @internal
- */ function createUtilityFunctions(opts) {
-    const { client , queryClient  } = opts;
-    const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
-    return {
-        fetchQuery: (queryKey, opts)=>{
-            return queryClient.fetchQuery({
-                ...opts,
-                queryKey,
-                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
-            });
-        },
-        fetchInfiniteQuery: (queryKey, opts)=>{
-            return queryClient.fetchInfiniteQuery({
-                ...opts,
-                queryKey,
-                queryFn: ({ pageParam  })=>{
-                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
-                },
-                initialPageParam: opts?.initialCursor ?? null
-            });
-        },
-        prefetchQuery: (queryKey, opts)=>{
-            return queryClient.prefetchQuery({
-                ...opts,
-                queryKey,
-                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
-            });
-        },
-        prefetchInfiniteQuery: (queryKey, opts)=>{
-            return queryClient.prefetchInfiniteQuery({
-                ...opts,
-                queryKey,
-                queryFn: ({ pageParam  })=>{
-                    return untypedClient.query(...getClientArgs(queryKey, opts, pageParam));
-                },
-                initialPageParam: opts?.initialCursor ?? null
-            });
-        },
-        ensureQueryData: (queryKey, opts)=>{
-            return queryClient.ensureQueryData({
-                ...opts,
-                queryKey,
-                queryFn: ()=>untypedClient.query(...getClientArgs(queryKey, opts))
-            });
-        },
-        invalidateQueries: (queryKey, filters, options)=>{
-            return queryClient.invalidateQueries({
-                ...filters,
-                queryKey
-            }, options);
-        },
-        resetQueries: (queryKey, filters, options)=>{
-            return queryClient.resetQueries({
-                ...filters,
-                queryKey
-            }, options);
-        },
-        refetchQueries: (queryKey, filters, options)=>{
-            return queryClient.refetchQueries({
-                ...filters,
-                queryKey
-            }, options);
-        },
-        cancelQuery: (queryKey, options)=>{
-            return queryClient.cancelQueries({
-                queryKey
-            }, options);
-        },
-        setQueryData: (queryKey, updater, options)=>{
-            return queryClient.setQueryData(queryKey, updater, options);
-        },
-        getQueryData: (queryKey)=>{
-            return queryClient.getQueryData(queryKey);
-        },
-        setInfiniteQueryData: (queryKey, updater, options)=>{
-            return queryClient.setQueryData(queryKey, updater, options);
-        },
-        getInfiniteQueryData: (queryKey)=>{
-            return queryClient.getQueryData(queryKey);
-        }
-    };
-}
+import { createTRPCUntypedClient } from '@trpc/client';
+import React, { useState, useMemo, useEffect, useRef } from 'react';
+import { TRPCContext } from '../../internals/context.mjs';
+import { getClientArgs } from '../../internals/getClientArgs.mjs';
+import { getQueryKeyInternal } from '../../internals/getQueryKey.mjs';
+import { useHookResult } from '../../internals/useHookResult.mjs';
+import { createUtilityFunctions } from '../../utils/createUtilityFunctions.mjs';
+import { createUseQueries } from '../proxy/useQueriesProxy.mjs';
 
 /**
  * @internal
@@ -168,15 +18,15 @@ import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601
     };
     const TRPCProvider = (props)=>{
         const { abortOnUnmount =false , client , queryClient , ssrContext  } = props;
-        const [ssrState, setSSRState] = React.useState(props.ssrState ?? false);
-        const fns = React.useMemo(()=>createUtilityFunctions({
+        const [ssrState, setSSRState] = useState(props.ssrState ?? false);
+        const fns = useMemo(()=>createUtilityFunctions({
                 client,
                 queryClient
             }), [
             client,
             queryClient
         ]);
-        const contextValue = React.useMemo(()=>({
+        const contextValue = useMemo(()=>({
                 abortOnUnmount,
                 queryClient,
                 client,
@@ -191,7 +41,7 @@ import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601
             ssrContext,
             ssrState
         ]);
-        React.useEffect(()=>{
+        useEffect(()=>{
             // Only updating state to `mounted` if we are using SSR.
             // This makes it so we don't have an unnecessary re-render when opting out of SSR.
             setSSRState((state)=>state ? 'mounted' : false);
@@ -317,9 +167,9 @@ import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601
         const enabled = opts?.enabled ?? true;
         const queryKey = hashKey(getQueryKeyInternal(path, input, 'any'));
         const { client  } = useContext();
-        const optsRef = React.useRef(opts);
+        const optsRef = useRef(opts);
         optsRef.current = opts;
-        React.useEffect(()=>{
+        useEffect(()=>{
             if (!enabled) {
                 return;
             }
@@ -465,7 +315,7 @@ import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601
         ];
     };
     const useDehydratedState = (client, trpcState)=>{
-        const transformed = React.useMemo(()=>{
+        const transformed = useMemo(()=>{
             if (!trpcState) {
                 return trpcState;
             }
@@ -493,4 +343,4 @@ import { b as getQueryKeyInternal, T as TRPCContext } from './utilsProxy-61a4601
     };
 }
 
-export { createReactDecoration as a, createUtilityFunctions as b, createRootHooks as c, createUseQueries as d, getClientArgs as g };
+export { createRootHooks };

package/dist/shared/index.js

@@ -1,24 +1,22 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var decorationProxy = require('./proxy/decorationProxy.js');
+var utilsProxy = require('./proxy/utilsProxy.js');
+var useQueriesProxy = require('./proxy/useQueriesProxy.js');
+var createHooksInternal = require('./hooks/createHooksInternal.js');
+var queryClient = require('./queryClient.js');
+var getClientArgs = require('../internals/getClientArgs.js');
+var context = require('../internals/context.js');
 
-var createHooksInternal = require('../createHooksInternal-5d2fa367.js');
-var utilsProxy = require('../utilsProxy-0b88c1e3.js');
-var queryClient = require('../queryClient-358a9a75.js');
-require('@trpc/core');
-require('@tanstack/react-query');
-require('@trpc/client');
-require('react');
 
 
-
-exports.createReactDecoration = createHooksInternal.createReactDecoration;
-exports.createRootHooks = createHooksInternal.createRootHooks;
-exports.createUseQueries = createHooksInternal.createUseQueries;
-exports.getClientArgs = createHooksInternal.getClientArgs;
-exports.TRPCContext = utilsProxy.TRPCContext;
-exports.contextProps = utilsProxy.contextProps;
+exports.createReactDecoration = decorationProxy.createReactDecoration;
 exports.createQueryUtilsProxy = utilsProxy.createQueryUtilsProxy;
 exports.createReactQueryUtils = utilsProxy.createReactQueryUtils;
 exports.getQueryType = utilsProxy.getQueryType;
+exports.createUseQueries = useQueriesProxy.createUseQueries;
+exports.createRootHooks = createHooksInternal.createRootHooks;
 exports.getQueryClient = queryClient.getQueryClient;
+exports.getClientArgs = getClientArgs.getClientArgs;
+exports.TRPCContext = context.TRPCContext;
+exports.contextProps = context.contextProps;

package/dist/shared/index.mjs

@@ -1,7 +1,7 @@
-export { a as createReactDecoration, c as createRootHooks, d as createUseQueries, g as getClientArgs } from '../createHooksInternal-e0b0564e.mjs';
-export { T as TRPCContext, e as contextProps, a as createQueryUtilsProxy, c as createReactQueryUtils, d as getQueryType } from '../utilsProxy-61a4601f.mjs';
-export { g as getQueryClient } from '../queryClient-4d766c0c.mjs';
-import '@trpc/core';
-import '@tanstack/react-query';
-import '@trpc/client';
-import 'react';
+export { createReactDecoration } from './proxy/decorationProxy.mjs';
+export { createQueryUtilsProxy, createReactQueryUtils, getQueryType } from './proxy/utilsProxy.mjs';
+export { createUseQueries } from './proxy/useQueriesProxy.mjs';
+export { createRootHooks } from './hooks/createHooksInternal.mjs';
+export { getQueryClient } from './queryClient.mjs';
+export { getClientArgs } from '../internals/getClientArgs.mjs';
+export { TRPCContext, contextProps } from '../internals/context.mjs';

package/dist/shared/proxy/decorationProxy.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var core = require('@trpc/core');
+
+/**
+ * Create proxy for decorating procedures
+ * @internal
+ */ function createReactDecoration(name, hooks) {
+    return core.createRecursiveProxy(({ path , args  })=>{
+        const pathCopy = [
+            name,
+            ...path
+        ];
+        // The last arg is for instance `.useMutation` or `.useQuery()`
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lastArg = pathCopy.pop();
+        if (lastArg === 'useMutation') {
+            return hooks[lastArg](pathCopy, ...args);
+        }
+        if (lastArg === '_def') {
+            return {
+                path: pathCopy
+            };
+        }
+        const [input, ...rest] = args;
+        const opts = rest[0] || {};
+        return hooks[lastArg](pathCopy, input, opts);
+    });
+}
+
+exports.createReactDecoration = createReactDecoration;

package/dist/shared/proxy/decorationProxy.mjs

@@ -0,0 +1,29 @@
+import { createRecursiveProxy } from '@trpc/core';
+
+/**
+ * Create proxy for decorating procedures
+ * @internal
+ */ function createReactDecoration(name, hooks) {
+    return createRecursiveProxy(({ path , args  })=>{
+        const pathCopy = [
+            name,
+            ...path
+        ];
+        // The last arg is for instance `.useMutation` or `.useQuery()`
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const lastArg = pathCopy.pop();
+        if (lastArg === 'useMutation') {
+            return hooks[lastArg](pathCopy, ...args);
+        }
+        if (lastArg === '_def') {
+            return {
+                path: pathCopy
+            };
+        }
+        const [input, ...rest] = args;
+        const opts = rest[0] || {};
+        return hooks[lastArg](pathCopy, input, opts);
+    });
+}
+
+export { createReactDecoration };

package/dist/shared/proxy/useQueriesProxy.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var core = require('@trpc/core');
+var getQueryKey = require('../../internals/getQueryKey.js');
+
+/**
+ * Create proxy for `useQueries` options
+ * @internal
+ */ function createUseQueries(client) {
+    return core.createRecursiveProxy((opts)=>{
+        const arrayPath = opts.path;
+        const dotPath = arrayPath.join('.');
+        const [input, _opts] = opts.args;
+        const options = {
+            queryKey: getQueryKey.getQueryKeyInternal(arrayPath, input, 'query'),
+            queryFn: ()=>{
+                return client.query(dotPath, input, _opts?.trpc);
+            },
+            ..._opts
+        };
+        return options;
+    });
+}
+
+exports.createUseQueries = createUseQueries;

package/dist/shared/proxy/useQueriesProxy.mjs

@@ -0,0 +1,23 @@
+import { createRecursiveProxy } from '@trpc/core';
+import { getQueryKeyInternal } from '../../internals/getQueryKey.mjs';
+
+/**
+ * Create proxy for `useQueries` options
+ * @internal
+ */ function createUseQueries(client) {
+    return createRecursiveProxy((opts)=>{
+        const arrayPath = opts.path;
+        const dotPath = arrayPath.join('.');
+        const [input, _opts] = opts.args;
+        const options = {
+            queryKey: getQueryKeyInternal(arrayPath, input, 'query'),
+            queryFn: ()=>{
+                return client.query(dotPath, input, _opts?.trpc);
+            },
+            ..._opts
+        };
+        return options;
+    });
+}
+
+export { createUseQueries };

package/dist/shared/proxy/utilsProxy.js

@@ -0,0 +1,89 @@
+'use strict';
+
+var client = require('@trpc/client');
+var core = require('@trpc/core');
+var context = require('../../internals/context.js');
+var getQueryKey = require('../../internals/getQueryKey.js');
+
+const getQueryType = (utilName)=>{
+    switch(utilName){
+        case 'fetch':
+        case 'ensureData':
+        case 'prefetch':
+        case 'getData':
+        case 'setData':
+            return 'query';
+        case 'fetchInfinite':
+        case 'prefetchInfinite':
+        case 'getInfiniteData':
+        case 'setInfiniteData':
+            return 'infinite';
+        case 'cancel':
+        case 'invalidate':
+        case 'refetch':
+        case 'reset':
+            return 'any';
+    }
+};
+/**
+ * @internal
+ */ function createRecursiveUtilsProxy(context, key) {
+    return core.createRecursiveProxy((opts)=>{
+        const path = [
+            key,
+            ...opts.path
+        ];
+        const utilName = path.pop();
+        const args = [
+            ...opts.args
+        ];
+        const input = args.shift(); // args can now be spread when input removed
+        const queryType = getQueryType(utilName);
+        const queryKey = getQueryKey.getQueryKeyInternal(path, input, queryType);
+        const contextMap = {
+            fetch: ()=>context.fetchQuery(queryKey, ...args),
+            fetchInfinite: ()=>context.fetchInfiniteQuery(queryKey, args[0]),
+            prefetch: ()=>context.prefetchQuery(queryKey, ...args),
+            prefetchInfinite: ()=>context.prefetchInfiniteQuery(queryKey, args[0]),
+            ensureData: ()=>context.ensureQueryData(queryKey, ...args),
+            invalidate: ()=>context.invalidateQueries(queryKey, ...args),
+            reset: ()=>context.resetQueries(queryKey, ...args),
+            refetch: ()=>context.refetchQueries(queryKey, ...args),
+            cancel: ()=>context.cancelQuery(queryKey, ...args),
+            setData: ()=>{
+                context.setQueryData(queryKey, args[0], args[1]);
+            },
+            setInfiniteData: ()=>{
+                context.setInfiniteQueryData(queryKey, args[0], args[1]);
+            },
+            getData: ()=>context.getQueryData(queryKey),
+            getInfiniteData: ()=>context.getInfiniteQueryData(queryKey)
+        };
+        return contextMap[utilName]();
+    });
+}
+/**
+ * @internal
+ */ function createReactQueryUtils(context$1) {
+    return core.createFlatProxy((key)=>{
+        const contextName = key;
+        if (contextName === 'client') {
+            return client.createTRPCClientProxy(context$1.client);
+        }
+        if (context.contextProps.includes(contextName)) {
+            return context$1[contextName];
+        }
+        return createRecursiveUtilsProxy(context$1, key);
+    });
+}
+/**
+ * @internal
+ */ function createQueryUtilsProxy(context) {
+    return core.createFlatProxy((key)=>{
+        return createRecursiveUtilsProxy(context, key);
+    });
+}
+
+exports.createQueryUtilsProxy = createQueryUtilsProxy;
+exports.createReactQueryUtils = createReactQueryUtils;
+exports.getQueryType = getQueryType;

package/dist/{utilsProxy-61a4601f.mjs → shared/proxy/utilsProxy.mjs}

@@ -1,55 +1,7 @@
 import { createTRPCClientProxy } from '@trpc/client';
 import { createFlatProxy, createRecursiveProxy } from '@trpc/core';
-import * as React from 'react';
-
-/**
- * To allow easy interactions with groups of related queries, such as
- * invalidating all queries of a router, we use an array as the path when
- * storing in tanstack query.
- **/ function getQueryKeyInternal(path, input, type) {
-    // Construct a query key that is easy to destructure and flexible for
-    // partial selecting etc.
-    // https://github.com/trpc/trpc/issues/3128
-    // some parts of the path may be dot-separated, split them up
-    const splitPath = path.flatMap((part)=>part.split('.'));
-    if (!input && (!type || type === 'any')) // for `utils.invalidate()` to match all queries (including vanilla react-query)
-    // we don't want nested array if path is empty, i.e. `[]` instead of `[[]]`
-    return splitPath.length ? [
-        splitPath
-    ] : [];
-    return [
-        splitPath,
-        {
-            ...typeof input !== 'undefined' && {
-                input: input
-            },
-            ...type && type !== 'any' && {
-                type: type
-            }
-        }
-    ];
-}
-/**
- * Method to extract the query key for a procedure
- * @param procedureOrRouter - procedure or AnyRouter
- * @param input - input to procedureOrRouter
- * @param type - defaults to `any`
- * @link https://trpc.io/docs/v11/getQueryKey
- */ function getQueryKey(..._params) {
-    const [procedureOrRouter, input, type] = _params;
-    // @ts-expect-error - we don't expose _def on the type layer
-    const path = procedureOrRouter._def().path;
-    const queryKey = getQueryKeyInternal(path, input, type ?? 'any');
-    return queryKey;
-}
-
-const contextProps = [
-    'client',
-    'ssrContext',
-    'ssrState',
-    'abortOnUnmount'
-];
-const TRPCContext = React.createContext?.(null);
+import { contextProps } from '../../internals/context.mjs';
+import { getQueryKeyInternal } from '../../internals/getQueryKey.mjs';
 
 const getQueryType = (utilName)=>{
     switch(utilName){
@@ -130,4 +82,4 @@ const getQueryType = (utilName)=>{
     });
 }
 
-export { TRPCContext as T, createQueryUtilsProxy as a, getQueryKeyInternal as b, createReactQueryUtils as c, getQueryType as d, contextProps as e, getQueryKey as g };
+export { createQueryUtilsProxy, createReactQueryUtils, getQueryType };

package/dist/{queryClient-4d766c0c.mjs → shared/queryClient.mjs}

@@ -4,4 +4,4 @@ import { QueryClient } from '@tanstack/react-query';
  * @internal
  */ const getQueryClient = (config)=>config.queryClient ?? new QueryClient(config.queryClientConfig);
 
-export { getQueryClient as g };
+export { getQueryClient };

package/dist/utils/createUtilityFunctions.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var client = require('@trpc/client');
+var getClientArgs = require('../internals/getClientArgs.js');
+
+/**
+ * Creates a set of utility functions that can be used to interact with `react-query`
+ * @param opts the `TRPCClient` and `QueryClient` to use
+ * @returns a set of utility functions that can be used to interact with `react-query`
+ * @internal
+ */ function createUtilityFunctions(opts) {
+    const { client: client$1 , queryClient  } = opts;
+    const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
+    return {
+        fetchQuery: (queryKey, opts)=>{
+            return queryClient.fetchQuery({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs.getClientArgs(queryKey, opts))
+            });
+        },
+        fetchInfiniteQuery: (queryKey, opts)=>{
+            return queryClient.fetchInfiniteQuery({
+                ...opts,
+                queryKey,
+                queryFn: ({ pageParam  })=>{
+                    return untypedClient.query(...getClientArgs.getClientArgs(queryKey, opts, pageParam));
+                },
+                initialPageParam: opts?.initialCursor ?? null
+            });
+        },
+        prefetchQuery: (queryKey, opts)=>{
+            return queryClient.prefetchQuery({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs.getClientArgs(queryKey, opts))
+            });
+        },
+        prefetchInfiniteQuery: (queryKey, opts)=>{
+            return queryClient.prefetchInfiniteQuery({
+                ...opts,
+                queryKey,
+                queryFn: ({ pageParam  })=>{
+                    return untypedClient.query(...getClientArgs.getClientArgs(queryKey, opts, pageParam));
+                },
+                initialPageParam: opts?.initialCursor ?? null
+            });
+        },
+        ensureQueryData: (queryKey, opts)=>{
+            return queryClient.ensureQueryData({
+                ...opts,
+                queryKey,
+                queryFn: ()=>untypedClient.query(...getClientArgs.getClientArgs(queryKey, opts))
+            });
+        },
+        invalidateQueries: (queryKey, filters, options)=>{
+            return queryClient.invalidateQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        resetQueries: (queryKey, filters, options)=>{
+            return queryClient.resetQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        refetchQueries: (queryKey, filters, options)=>{
+            return queryClient.refetchQueries({
+                ...filters,
+                queryKey
+            }, options);
+        },
+        cancelQuery: (queryKey, options)=>{
+            return queryClient.cancelQueries({
+                queryKey
+            }, options);
+        },
+        setQueryData: (queryKey, updater, options)=>{
+            return queryClient.setQueryData(queryKey, updater, options);
+        },
+        getQueryData: (queryKey)=>{
+            return queryClient.getQueryData(queryKey);
+        },
+        setInfiniteQueryData: (queryKey, updater, options)=>{
+            return queryClient.setQueryData(queryKey, updater, options);
+        },
+        getInfiniteQueryData: (queryKey)=>{
+            return queryClient.getQueryData(queryKey);
+        }
+    };
+}
+
+exports.createUtilityFunctions = createUtilityFunctions;