@apollo/client 4.2.0-alpha.0 → 4.2.0-alpha.2

package/__cjs/react/hooks/useQuery.d.cts

@@ -2,7 +2,7 @@ import type { DataState, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, G
 import type { ApolloClient } from "@apollo/client";
 import { NetworkStatus } from "@apollo/client";
 import type { MaybeMasked } from "@apollo/client/masking";
-import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, VariablesOption } from "@apollo/client/utilities/internal";
+import type { DocumentationTypes as UtilityDocumentationTypes, LazyType, NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 import type { SkipToken } from "./constants.cjs";
 export declare namespace useQuery {
     namespace Base {
@@ -226,6 +226,10 @@ export declare namespace useQuery {
         }
     }
     type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"], TReturnVariables extends OperationVariables = TVariables> = Base.Result<TData, TVariables, TReturnVariables> & GetDataState<MaybeMasked<TData>, TStates>;
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+        skip: false;
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options<TData, TVariables> | SkipToken> = LazyType<Result<TData, TVariables, "complete" | "streaming" | "empty" | (TOptions extends any ? TOptions extends SkipToken ? never : OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial" : never)>>;
     namespace DocumentationTypes {
         namespace useQuery {
             interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Result<TData, TVariables>, UtilityDocumentationTypes.DataState<TData> {
@@ -234,316 +238,142 @@ export declare namespace useQuery {
     }
     namespace DocumentationTypes {
         /**
-        * A hook for executing queries in an Apollo application.
-        * 
-        * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-        * 
-        * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-        * 
-        * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-        * 
-        * @example
-        * 
-        * ```jsx
-        * import { gql } from "@apollo/client";
-        * import { useQuery } from "@apollo/client/react";
-        * 
-        * const GET_GREETING = gql`
-        *   query GetGreeting($language: String!) {
-        *     greeting(language: $language) {
-        *       message
-        *     }
-        *   }
-        * `;
+         * A hook for executing queries in an Apollo application.
+         *
+         * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+         *
+         * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+         *
+         * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+         *
+         * @example
+         *
+         * ```jsx
+         * import { gql } from "@apollo/client";
+         * import { useQuery } from "@apollo/client/react";
+         *
+         * const GET_GREETING = gql`
+         *   query GetGreeting($language: String!) {
+         *     greeting(language: $language) {
+         *       message
+         *     }
+         *   }
+         * `;
+         *
+         * function Hello() {
+         *   const { loading, error, data } = useQuery(GET_GREETING, {
+         *     variables: { language: "english" },
+         *   });
+         *   if (loading) return <p>Loading ...</p>;
+         *   return <h1>Hello {data.greeting.message}!</h1>;
+         * }
+         * ```
+         *
+         * @param query - A GraphQL query document parsed into an AST by `gql`.
+         * @param options - Options to control how the query is executed.
+         * @returns Query result object
+         */
+        interface useQuery {
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
+        }
+        /**
+        * @deprecated Avoid manually specifying generics on `useQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        */
+        interface useQuery_Deprecated {
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
+        }
+    }
+    namespace Signatures {
+        /**
         * 
-        * function Hello() {
-        *   const { loading, error, data } = useQuery(GET_GREETING, {
-        *     variables: { language: "english" },
-        *   });
-        *   if (loading) return <p>Loading ...</p>;
-        *   return <h1>Hello {data.greeting.message}!</h1>;
-        * }
-        * ```
+        */
+        interface Classic {
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: true;
+            })): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: boolean;
+            }): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: boolean;
+            })): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
+            ] : [options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming">;
+            /**
+            * 
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
+            ] : [
+                options: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
+            ]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming", Partial<TVariables>>;
+            ssrDisabledResult: ObservableQuery.Result<any>;
+        }
+        /**
         * 
-        * @param query - A GraphQL query document parsed into an AST by `gql`.
-        * @param options - Options to control how the query is executed.
-        * @returns Query result object
         */
-        function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
+        interface Modern {
+            /**
+            * 
+            */
+            <TData, TVariables extends OperationVariables, Options extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): useQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * 
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends SkipToken>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
+            /**
+            * 
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useQuery.Options<TData, NoInfer<TVariables>> & VariablesOption<TVariables & {
+                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: [
+                TVariables
+            ] extends [never] ? [options: never] : {} extends TVariables ? [options?: TOptions] : [
+                options: TOptions
+            ]): useQuery.ResultForOptions<TData, TVariables, TOptions>;
+            /**
+            * 
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useQuery.Options<TData, NoInfer<TVariables>> & VariablesOption<TVariables & {
+                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: [
+                TVariables
+            ] extends [never] ? [options: never] : {} extends TVariables ? [options?: TOptions | SkipToken] : [
+                options: TOptions | SkipToken
+            ]): useQuery.ResultForOptions<TData, TVariables, TOptions | SkipToken>;
+            ssrDisabledResult: ObservableQuery.Result<any>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+    /**
+    * 
+    */
+    interface Signature extends Signatures.Evaluated {
     }
 }
-/**
- * A hook for executing queries in an Apollo application.
- *
- * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
- *
- * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
- *
- * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
- *
- * @example
- *
- * ```jsx
- * import { gql } from "@apollo/client";
- * import { useQuery } from "@apollo/client/react";
- *
- * const GET_GREETING = gql`
- *   query GetGreeting($language: String!) {
- *     greeting(language: $language) {
- *       message
- *     }
- *   }
- * `;
- *
- * function Hello() {
- *   const { loading, error, data } = useQuery(GET_GREETING, {
- *     variables: { language: "english" },
- *   });
- *   if (loading) return <p>Loading ...</p>;
- *   return <h1>Hello {data.greeting.message}!</h1>;
- * }
- * ```
- *
- * @param query - A GraphQL query document parsed into an AST by `gql`.
- * @param options - Options to control how the query is executed.
- * @returns Query result object
- */
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: true;
-}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: true;
-})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-}): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-})): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
-] : [options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming">;
-/**
-* A hook for executing queries in an Apollo application.
-* 
-* To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-* 
-* When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-* 
-* > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const { loading, error, data } = useQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (loading) return <p>Loading ...</p>;
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns Query result object
-*/
-export declare function useQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
-] : [options: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming", Partial<TVariables>>;
-export declare namespace useQuery {
-    var ssrDisabledResult: ObservableQuery.Result<any, "complete" | "empty" | "streaming" | "partial">;
-}
+export declare const useQuery: useQuery.Signature;
 //# sourceMappingURL=useQuery.d.cts.map

package/__cjs/react/hooks/useSuspenseQuery.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSuspenseQuery = useSuspenseQuery;
+exports.useSuspenseQuery = void 0;
 exports.useWatchQueryOptions = useWatchQueryOptions;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
@@ -12,10 +12,10 @@ const constants_js_1 = require("./constants.cjs");
 const index_js_1 = require("./internal/index.cjs");
 const validateSuspenseHookOptions_js_1 = require("./internal/validateSuspenseHookOptions.cjs");
 const useApolloClient_js_1 = require("./useApolloClient.cjs");
-function useSuspenseQuery(query, options) {
+exports.useSuspenseQuery = function useSuspenseQuery(query, options) {
     "use no memo";
     return (0, index_js_1.wrapHook)("useSuspenseQuery", useSuspenseQuery_, (0, useApolloClient_js_1.useApolloClient)(typeof options === "object" ? options.client : undefined))(query, options ?? {});
-}
+};
 function useSuspenseQuery_(query, options) {
     const client = (0, useApolloClient_js_1.useApolloClient)(options.client);
     const suspenseCache = (0, internal_1.getSuspenseCache)(client);