@orpc/react 0.27.0 → 0.53.0

package/dist/index.js

@@ -1,672 +0,0 @@
-// src/general-hooks.ts
-import {
-  useIsFetching,
-  useIsMutating,
-  useMutationState
-} from "@tanstack/react-query";
-
-// src/react-context.ts
-import { createContext, useContext } from "react";
-function createORPCContext() {
-  return createContext(void 0);
-}
-function useORPCContext(context) {
-  const value = useContext(context);
-  if (!value) {
-    throw new Error(
-      "useORPCContext must be used within a <ORPCContext.Provider>, please see the docs"
-    );
-  }
-  return value;
-}
-
-// src/orpc-path.ts
-var orpcPathSymbol = Symbol("orpcPathSymbol");
-
-// src/tanstack-key.ts
-function getQueryKeyFromPath(path, options) {
-  const withInput = options?.input !== void 0 ? { input: options?.input } : {};
-  const withType = options?.type !== void 0 ? { type: options?.type } : {};
-  return [
-    path,
-    {
-      ...withInput,
-      ...withType
-    }
-  ];
-}
-function getMutationKeyFromPath(path) {
-  return [path];
-}
-
-// src/general-hooks.ts
-function createGeneralHooks(options) {
-  return {
-    useIsFetching(filters) {
-      const { queryType, input, ...rest } = filters ?? {};
-      const context = useORPCContext(options.context);
-      return useIsFetching(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType
-          }),
-          ...rest
-        },
-        context.queryClient
-      );
-    },
-    useIsMutating(filters) {
-      const context = useORPCContext(options.context);
-      return useIsMutating(
-        { mutationKey: getMutationKeyFromPath(options.path), ...filters },
-        context.queryClient
-      );
-    },
-    useMutationState(options_) {
-      const context = useORPCContext(options.context);
-      return useMutationState(
-        {
-          ...options_,
-          filters: {
-            mutationKey: getMutationKeyFromPath(options.path),
-            ...options_?.filters
-          }
-        },
-        context.queryClient
-      );
-    }
-  };
-}
-
-// src/general-utils.ts
-function createGeneralUtils(options) {
-  return {
-    getQueriesData(filters) {
-      const { input, ...rest } = filters ?? {};
-      return options.queryClient.getQueriesData({
-        queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-        ...rest
-      });
-    },
-    getInfiniteQueriesData(filters) {
-      const { input, ...rest } = filters ?? {};
-      return options.queryClient.getQueriesData({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        }),
-        ...rest
-      });
-    },
-    setQueriesData(filters, updater, options_) {
-      const { input, ...rest } = filters;
-      return options.queryClient.setQueriesData(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: "query"
-          }),
-          ...rest
-        },
-        updater,
-        options_
-      );
-    },
-    setInfiniteQueriesData(filters, updater, options_) {
-      const { input, ...rest } = filters;
-      return options.queryClient.setQueriesData(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: "infinite"
-          }),
-          ...rest
-        },
-        updater,
-        options_
-      );
-    },
-    invalidate(filters, options_) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.invalidateQueries(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType
-          }),
-          ...rest
-        },
-        options_
-      );
-    },
-    refetch(filters, options_) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.refetchQueries(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType
-          }),
-          ...rest
-        },
-        options_
-      );
-    },
-    cancel(filters, options_) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.cancelQueries(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType
-          }),
-          ...rest
-        },
-        options_
-      );
-    },
-    remove(filters) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.removeQueries({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: queryType
-        }),
-        ...rest
-      });
-    },
-    reset(filters, options_) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.resetQueries(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: queryType
-          }),
-          ...rest
-        },
-        options_
-      );
-    },
-    isFetching(filters) {
-      const { input, queryType, ...rest } = filters ?? {};
-      return options.queryClient.isFetching({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: queryType
-        }),
-        ...rest
-      });
-    },
-    isMutating(filters) {
-      return options.queryClient.isMutating({
-        mutationKey: getMutationKeyFromPath(options.path),
-        ...filters
-      });
-    },
-    getQueryDefaults(filters) {
-      return options.queryClient.getQueryDefaults(
-        filters?.queryKey ?? getQueryKeyFromPath(options.path, {
-          input: filters?.input,
-          type: "query"
-        })
-      );
-    },
-    getInfiniteQueryDefaults(filters) {
-      return options.queryClient.getQueryDefaults(
-        filters?.queryKey ?? getQueryKeyFromPath(options.path, {
-          input: filters?.input,
-          type: "infinite"
-        })
-      );
-    },
-    setQueryDefaults(options_, filters) {
-      return options.queryClient.setQueryDefaults(
-        filters?.queryKey ?? getQueryKeyFromPath(options.path, {
-          input: filters?.input,
-          type: "query"
-        }),
-        options_
-      );
-    },
-    setInfiniteQueryDefaults(options_, filters) {
-      return options.queryClient.setQueryDefaults(
-        filters?.queryKey ?? getQueryKeyFromPath(options.path, {
-          input: filters?.input,
-          type: "infinite"
-        }),
-        options_
-      );
-    },
-    getMutationDefaults(filters) {
-      return options.queryClient.getMutationDefaults(
-        filters?.mutationKey ?? getMutationKeyFromPath(options.path)
-      );
-    },
-    setMutationDefaults(options_, filters) {
-      return options.queryClient.setMutationDefaults(
-        filters?.mutationKey ?? getMutationKeyFromPath(options.path),
-        options_
-      );
-    }
-  };
-}
-
-// src/procedure-hooks.ts
-import {
-  get
-} from "@orpc/shared";
-import {
-  useInfiniteQuery,
-  useMutation,
-  usePrefetchInfiniteQuery,
-  usePrefetchQuery,
-  useQuery,
-  useSuspenseInfiniteQuery,
-  useSuspenseQuery
-} from "@tanstack/react-query";
-function createProcedureHooks(options) {
-  return {
-    [orpcPathSymbol]: options.path,
-    useQuery(input, options_) {
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return useQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: ({ signal }) => client(input, { signal }),
-          ...options_
-        },
-        context.queryClient
-      );
-    },
-    useInfiniteQuery(options_) {
-      const { input, ...rest } = options_;
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return useInfiniteQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: "infinite"
-          }),
-          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
-          ...rest
-        },
-        context.queryClient
-      );
-    },
-    useSuspenseQuery(input, options_) {
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return useSuspenseQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: ({ signal }) => client(input, { signal }),
-          ...options_
-        },
-        context.queryClient
-      );
-    },
-    useSuspenseInfiniteQuery(options_) {
-      const { input, ...rest } = options_;
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return useSuspenseInfiniteQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: "infinite"
-          }),
-          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
-          ...rest
-        },
-        context.queryClient
-      );
-    },
-    usePrefetchQuery(input, options_) {
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return usePrefetchQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: ({ signal }) => client(input, { signal }),
-          ...options_
-        },
-        context.queryClient
-      );
-    },
-    usePrefetchInfiniteQuery(options_) {
-      const { input, ...rest } = options_;
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return usePrefetchInfiniteQuery(
-        {
-          queryKey: getQueryKeyFromPath(options.path, {
-            input,
-            type: "infinite"
-          }),
-          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
-          ...rest
-        },
-        context.queryClient
-      );
-    },
-    useMutation(options_) {
-      const context = useORPCContext(options.context);
-      const client = get(context.client, options.path);
-      return useMutation(
-        {
-          mutationKey: getMutationKeyFromPath(options.path),
-          mutationFn: (input) => client(input),
-          ...options_
-        },
-        context.queryClient
-      );
-    }
-  };
-}
-
-// src/procedure-utils.ts
-function createProcedureUtils(options) {
-  return {
-    fetchQuery(input, options_) {
-      return options.queryClient.fetchQuery({
-        queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-        queryFn: ({ signal }) => options.client(input, { signal }),
-        ...options_
-      });
-    },
-    fetchInfiniteQuery(options_) {
-      const { input, ...rest } = options_;
-      return options.queryClient.fetchInfiniteQuery({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        }),
-        queryFn: ({ pageParam, signal }) => {
-          return options.client({ ...input, pageParam }, { signal });
-        },
-        ...rest
-      });
-    },
-    prefetchQuery(input, options_) {
-      return options.queryClient.prefetchQuery({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "query"
-        }),
-        queryFn: ({ signal }) => options.client(input, { signal }),
-        ...options_
-      });
-    },
-    prefetchInfiniteQuery(options_) {
-      const { input, ...rest } = options_;
-      return options.queryClient.prefetchInfiniteQuery({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        }),
-        queryFn: ({ pageParam, signal }) => {
-          return options.client({ ...input, cursor: pageParam }, { signal });
-        },
-        ...rest
-      });
-    },
-    getQueryData(input) {
-      return options.queryClient.getQueryData(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "query"
-        })
-      );
-    },
-    getInfiniteQueryData(input) {
-      return options.queryClient.getQueryData(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        })
-      );
-    },
-    ensureQueryData(input, options_) {
-      return options.queryClient.ensureQueryData({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "query"
-        }),
-        queryFn: ({ signal }) => options.client(input, { signal }),
-        ...options_
-      });
-    },
-    ensureInfiniteQueryData(options_) {
-      const { input, ...rest } = options_;
-      return options.queryClient.ensureInfiniteQueryData({
-        queryKey: getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        }),
-        queryFn: ({ pageParam, signal }) => {
-          return options.client({ ...input, pageParam }, { signal });
-        },
-        ...rest
-      });
-    },
-    getQueryState(input) {
-      return options.queryClient.getQueryState(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "query"
-        })
-      );
-    },
-    getInfiniteQueryState(input) {
-      return options.queryClient.getQueryState(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        })
-      );
-    },
-    setQueryData(input, updater, options_) {
-      return options.queryClient.setQueryData(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "query"
-        }),
-        updater,
-        options_
-      );
-    },
-    setInfiniteQueryData(input, updater, options_) {
-      return options.queryClient.setQueryData(
-        getQueryKeyFromPath(options.path, {
-          input,
-          type: "infinite"
-        }),
-        updater,
-        options_
-      );
-    }
-  };
-}
-
-// src/react-hooks.ts
-function createORPCHooks(options) {
-  const path = options.path ?? [];
-  const generalHooks = createGeneralHooks({ context: options.context, path });
-  const procedureHooks = createProcedureHooks({
-    context: options.context,
-    path
-  });
-  return new Proxy(
-    {
-      [orpcPathSymbol]: path,
-      ...generalHooks,
-      ...procedureHooks
-    },
-    {
-      get(target, key) {
-        const value = Reflect.get(target, key);
-        if (typeof key !== "string") {
-          return value;
-        }
-        const nextHooks = createORPCHooks({
-          context: options.context,
-          path: [...path, key]
-        });
-        if (typeof value !== "function") {
-          return nextHooks;
-        }
-        return new Proxy(value, {
-          get(_, key2) {
-            return Reflect.get(nextHooks, key2);
-          }
-        });
-      }
-    }
-  );
-}
-
-// src/react-utils.ts
-function createORPCUtils(options) {
-  const path = options.path ?? [];
-  const client = options.contextValue.client;
-  const generalUtils = createGeneralUtils({
-    queryClient: options.contextValue.queryClient,
-    path
-  });
-  const procedureUtils = path.length ? createProcedureUtils({
-    client,
-    queryClient: options.contextValue.queryClient,
-    path
-  }) : {};
-  return new Proxy(
-    {
-      ...generalUtils,
-      ...procedureUtils
-    },
-    {
-      get(target, key) {
-        const value = Reflect.get(target, key);
-        if (typeof key !== "string") {
-          return value;
-        }
-        const nextUtils = createORPCUtils({
-          ...options,
-          contextValue: {
-            ...options.contextValue,
-            client: client[key]
-          },
-          path: [...path, key]
-        });
-        if (typeof value !== "function") {
-          return nextUtils;
-        }
-        return new Proxy(value, {
-          get(_, key2) {
-            return Reflect.get(nextUtils, key2);
-          }
-        });
-      }
-    }
-  );
-}
-
-// src/use-queries/hook.ts
-import { useQueries } from "@tanstack/react-query";
-
-// src/use-queries/builder.ts
-function createUseQueriesBuilder(options) {
-  return (input, options_) => {
-    return {
-      queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-      queryFn: ({ signal }) => options.client(input, { signal }),
-      ...options_
-    };
-  };
-}
-
-// src/use-queries/builders.ts
-function createUseQueriesBuilders(options) {
-  const path = options.path ?? [];
-  const client = options.client;
-  const builder = path.length ? createUseQueriesBuilder({ client, path }) : {};
-  return new Proxy(builder, {
-    get(target, key) {
-      const value = Reflect.get(target, key);
-      if (typeof key !== "string") {
-        return value;
-      }
-      const nextBuilders = createUseQueriesBuilders({
-        client: client[key],
-        path: [...path, key]
-      });
-      if (typeof value !== "function") {
-        return nextBuilders;
-      }
-      return new Proxy(value, {
-        get(_, key2) {
-          return Reflect.get(nextBuilders, key2);
-        }
-      });
-    }
-  });
-}
-
-// src/use-queries/hook.ts
-function useQueriesFactory(options) {
-  const Hook = (build, combine) => {
-    const orpc = useORPCContext(options.context);
-    const builders = createUseQueriesBuilders({ client: orpc.client });
-    return useQueries({
-      queries: build(builders),
-      combine
-    });
-  };
-  return Hook;
-}
-
-// src/react.tsx
-function createORPCReact() {
-  const Context = createORPCContext();
-  const useContext2 = () => useORPCContext(Context);
-  const useUtils = () => createORPCUtils({ contextValue: useContext2() });
-  const useQueries2 = useQueriesFactory({ context: Context });
-  const hooks = createORPCHooks({ context: Context });
-  const orpc = new Proxy(
-    {
-      useContext: useContext2,
-      useUtils,
-      useQueries: useQueries2
-    },
-    {
-      get(target, key) {
-        const value = Reflect.get(target, key);
-        const nextHooks = Reflect.get(hooks, key);
-        if (typeof value !== "function") {
-          return nextHooks;
-        }
-        return new Proxy(value, {
-          get(_, key2) {
-            return Reflect.get(nextHooks, key2);
-          }
-        });
-      }
-    }
-  );
-  return { orpc, ORPCContext: Context };
-}
-export {
-  createGeneralHooks,
-  createGeneralUtils,
-  createORPCContext,
-  createORPCHooks,
-  createORPCReact,
-  createORPCUtils,
-  createProcedureHooks,
-  createProcedureUtils,
-  useORPCContext
-};
-//# sourceMappingURL=index.js.map

package/dist/src/general-hooks.d.ts

@@ -1,23 +0,0 @@
-import type { PartialDeep, SetOptional } from '@orpc/shared';
-import type { ORPCQueryFilters } from './tanstack-query';
-import { type DefaultError, type Mutation, type MutationFilters, type MutationState } from '@tanstack/react-query';
-import { type ORPCContext } from './react-context';
-export interface GeneralHooks<TInput, TOutput> {
-    useIsFetching: (filers?: ORPCQueryFilters<PartialDeep<TInput>>) => number;
-    useIsMutating: (filters?: SetOptional<MutationFilters, 'mutationKey'>) => number;
-    useMutationState: <UResult = MutationState<TOutput, DefaultError, TInput>>(options?: {
-        filters?: SetOptional<MutationFilters, 'mutationKey'>;
-        select?: (mutation: Mutation<TOutput, DefaultError, TInput>) => UResult;
-    }) => UResult[];
-}
-export interface CreateGeneralHooksOptions {
-    context: ORPCContext<any>;
-    /**
-     * The path of the router or procedure on server.
-     *
-     * @internal
-     */
-    path: string[];
-}
-export declare function createGeneralHooks<TInput, TOutput>(options: CreateGeneralHooksOptions): GeneralHooks<TInput, TOutput>;
-//# sourceMappingURL=general-hooks.d.ts.map