@trpc/react-query 11.0.0-next-beta.205 → 11.0.0-next-beta.208

package/dist/internals/useHookResult.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+/**
+ * Makes a stable reference of the `trpc` prop
+ */ function useHookResult(value) {
+    const ref = React__namespace.useRef(value);
+    ref.current.path = value.path;
+    return ref.current;
+}
+
+exports.useHookResult = useHookResult;

package/dist/internals/useHookResult.mjs

@@ -0,0 +1,11 @@
+import * as React from 'react';
+
+/**
+ * Makes a stable reference of the `trpc` prop
+ */ function useHookResult(value) {
+    const ref = React.useRef(value);
+    ref.current.path = value.path;
+    return ref.current;
+}
+
+export { useHookResult };

package/dist/server/index.js

@@ -1,107 +1,7 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var ssgProxy = require('./ssgProxy.js');
 
-var reactQuery = require('@tanstack/react-query');
-var client = require('@trpc/client');
-var core = require('@trpc/core');
-var utilsProxy = require('../utilsProxy-4f6da312.js');
-require('react');
-var queryClient = require('../queryClient-358a9a75.js');
 
-/**
- * Create functions you can use for server-side rendering / static generation
- * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
- */ function createServerSideHelpers(opts) {
-    const queryClient$1 = queryClient.getQueryClient(opts);
-    const resolvedOpts = (()=>{
-        if ('router' in opts) {
-            const { transformer , ctx , router  } = opts;
-            return {
-                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
-                query: (queryOpts)=>{
-                    return core.callProcedure({
-                        procedures: router._def.procedures,
-                        path: queryOpts.path,
-                        getRawInput: async ()=>queryOpts.input,
-                        ctx,
-                        type: 'query'
-                    });
-                }
-            };
-        }
-        const { client: client$1  } = opts;
-        const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
-        return {
-            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
-            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
-        };
-    })();
-    function _dehydrate(opts = {
-        shouldDehydrateQuery () {
-            // makes sure to serialize errors
-            return true;
-        }
-    }) {
-        const before = reactQuery.dehydrate(queryClient$1, opts);
-        const after = resolvedOpts.serialize(before);
-        return after;
-    }
-    return core.createFlatProxy((key)=>{
-        if (key === 'queryClient') return queryClient$1;
-        if (key === 'dehydrate') return _dehydrate;
-        return core.createRecursiveProxy((opts)=>{
-            const args = opts.args;
-            const input = args[0];
-            const arrayPath = [
-                key,
-                ...opts.path
-            ];
-            const utilName = arrayPath.pop();
-            const queryFn = ()=>resolvedOpts.query({
-                    path: arrayPath.join('.'),
-                    input
-                });
-            const queryKey = utilsProxy.getQueryKeyInternal(arrayPath, input, utilsProxy.getQueryType(utilName));
-            const helperMap = {
-                fetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient$1.fetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                fetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient$1.fetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                },
-                prefetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient$1.prefetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                prefetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient$1.prefetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                }
-            };
-            return helperMap[utilName]();
-        });
-    });
-}
 
-exports.createServerSideHelpers = createServerSideHelpers;
+exports.createServerSideHelpers = ssgProxy.createServerSideHelpers;

package/dist/server/index.mjs

@@ -1,103 +1 @@
-import { dehydrate } from '@tanstack/react-query';
-import { TRPCUntypedClient, getUntypedClient } from '@trpc/client';
-import { callProcedure, createFlatProxy, createRecursiveProxy } from '@trpc/core';
-import { b as getQueryKeyInternal, d as getQueryType } from '../utilsProxy-12979321.mjs';
-import 'react';
-import { g as getQueryClient } from '../queryClient-4d766c0c.mjs';
-
-/**
- * Create functions you can use for server-side rendering / static generation
- * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
- */ function createServerSideHelpers(opts) {
-    const queryClient = getQueryClient(opts);
-    const resolvedOpts = (()=>{
-        if ('router' in opts) {
-            const { transformer , ctx , router  } = opts;
-            return {
-                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
-                query: (queryOpts)=>{
-                    return callProcedure({
-                        procedures: router._def.procedures,
-                        path: queryOpts.path,
-                        getRawInput: async ()=>queryOpts.input,
-                        ctx,
-                        type: 'query'
-                    });
-                }
-            };
-        }
-        const { client  } = opts;
-        const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
-        return {
-            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
-            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
-        };
-    })();
-    function _dehydrate(opts = {
-        shouldDehydrateQuery () {
-            // makes sure to serialize errors
-            return true;
-        }
-    }) {
-        const before = dehydrate(queryClient, opts);
-        const after = resolvedOpts.serialize(before);
-        return after;
-    }
-    return createFlatProxy((key)=>{
-        if (key === 'queryClient') return queryClient;
-        if (key === 'dehydrate') return _dehydrate;
-        return createRecursiveProxy((opts)=>{
-            const args = opts.args;
-            const input = args[0];
-            const arrayPath = [
-                key,
-                ...opts.path
-            ];
-            const utilName = arrayPath.pop();
-            const queryFn = ()=>resolvedOpts.query({
-                    path: arrayPath.join('.'),
-                    input
-                });
-            const queryKey = getQueryKeyInternal(arrayPath, input, getQueryType(utilName));
-            const helperMap = {
-                fetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient.fetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                fetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient.fetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                },
-                prefetch: ()=>{
-                    const args1 = args[1];
-                    return queryClient.prefetchQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn
-                    });
-                },
-                prefetchInfinite: ()=>{
-                    const args1 = args[1];
-                    return queryClient.prefetchInfiniteQuery({
-                        ...args1,
-                        queryKey,
-                        queryFn,
-                        initialPageParam: args1?.initialCursor ?? null
-                    });
-                }
-            };
-            return helperMap[utilName]();
-        });
-    });
-}
-
-export { createServerSideHelpers };
+export { createServerSideHelpers } from './ssgProxy.mjs';

package/dist/server/ssgProxy.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var client = require('@trpc/client');
+var core = require('@trpc/core');
+var getQueryKey = require('../internals/getQueryKey.js');
+var utilsProxy = require('../shared/proxy/utilsProxy.js');
+require('react');
+require('../internals/context.js');
+var queryClient = require('../shared/queryClient.js');
+
+/**
+ * Create functions you can use for server-side rendering / static generation
+ * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
+ */ function createServerSideHelpers(opts) {
+    const queryClient$1 = queryClient.getQueryClient(opts);
+    const resolvedOpts = (()=>{
+        if ('router' in opts) {
+            const { transformer , ctx , router  } = opts;
+            return {
+                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
+                query: (queryOpts)=>{
+                    return core.callProcedure({
+                        procedures: router._def.procedures,
+                        path: queryOpts.path,
+                        getRawInput: async ()=>queryOpts.input,
+                        ctx,
+                        type: 'query'
+                    });
+                }
+            };
+        }
+        const { client: client$1  } = opts;
+        const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
+        return {
+            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
+            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
+        };
+    })();
+    function _dehydrate(opts = {
+        shouldDehydrateQuery () {
+            // makes sure to serialize errors
+            return true;
+        }
+    }) {
+        const before = reactQuery.dehydrate(queryClient$1, opts);
+        const after = resolvedOpts.serialize(before);
+        return after;
+    }
+    return core.createFlatProxy((key)=>{
+        if (key === 'queryClient') return queryClient$1;
+        if (key === 'dehydrate') return _dehydrate;
+        return core.createRecursiveProxy((opts)=>{
+            const args = opts.args;
+            const input = args[0];
+            const arrayPath = [
+                key,
+                ...opts.path
+            ];
+            const utilName = arrayPath.pop();
+            const queryFn = ()=>resolvedOpts.query({
+                    path: arrayPath.join('.'),
+                    input
+                });
+            const queryKey = getQueryKey.getQueryKeyInternal(arrayPath, input, utilsProxy.getQueryType(utilName));
+            const helperMap = {
+                fetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.fetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                fetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.fetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                },
+                prefetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.prefetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                prefetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient$1.prefetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                }
+            };
+            return helperMap[utilName]();
+        });
+    });
+}
+
+exports.createServerSideHelpers = createServerSideHelpers;

package/dist/server/ssgProxy.mjs

@@ -0,0 +1,105 @@
+import { dehydrate } from '@tanstack/react-query';
+import { TRPCUntypedClient, getUntypedClient } from '@trpc/client';
+import { callProcedure, createFlatProxy, createRecursiveProxy } from '@trpc/core';
+import { getQueryKeyInternal } from '../internals/getQueryKey.mjs';
+import { getQueryType } from '../shared/proxy/utilsProxy.mjs';
+import 'react';
+import '../internals/context.mjs';
+import { getQueryClient } from '../shared/queryClient.mjs';
+
+/**
+ * Create functions you can use for server-side rendering / static generation
+ * @link https://trpc.io/docs/v11/client/nextjs/server-side-helpers
+ */ function createServerSideHelpers(opts) {
+    const queryClient = getQueryClient(opts);
+    const resolvedOpts = (()=>{
+        if ('router' in opts) {
+            const { transformer , ctx , router  } = opts;
+            return {
+                serialize: transformer ? ('input' in transformer ? transformer.input : transformer).serialize : (obj)=>obj,
+                query: (queryOpts)=>{
+                    return callProcedure({
+                        procedures: router._def.procedures,
+                        path: queryOpts.path,
+                        getRawInput: async ()=>queryOpts.input,
+                        ctx,
+                        type: 'query'
+                    });
+                }
+            };
+        }
+        const { client  } = opts;
+        const untypedClient = client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
+        return {
+            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
+            serialize: (obj)=>untypedClient.runtime.transformer.serialize(obj)
+        };
+    })();
+    function _dehydrate(opts = {
+        shouldDehydrateQuery () {
+            // makes sure to serialize errors
+            return true;
+        }
+    }) {
+        const before = dehydrate(queryClient, opts);
+        const after = resolvedOpts.serialize(before);
+        return after;
+    }
+    return createFlatProxy((key)=>{
+        if (key === 'queryClient') return queryClient;
+        if (key === 'dehydrate') return _dehydrate;
+        return createRecursiveProxy((opts)=>{
+            const args = opts.args;
+            const input = args[0];
+            const arrayPath = [
+                key,
+                ...opts.path
+            ];
+            const utilName = arrayPath.pop();
+            const queryFn = ()=>resolvedOpts.query({
+                    path: arrayPath.join('.'),
+                    input
+                });
+            const queryKey = getQueryKeyInternal(arrayPath, input, getQueryType(utilName));
+            const helperMap = {
+                fetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient.fetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                fetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient.fetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                },
+                prefetch: ()=>{
+                    const args1 = args[1];
+                    return queryClient.prefetchQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn
+                    });
+                },
+                prefetchInfinite: ()=>{
+                    const args1 = args[1];
+                    return queryClient.prefetchInfiniteQuery({
+                        ...args1,
+                        queryKey,
+                        queryFn,
+                        initialPageParam: args1?.initialCursor ?? null
+                    });
+                }
+            };
+            return helperMap[utilName]();
+        });
+    });
+}
+
+export { createServerSideHelpers };