@depup/apollo__client 4.1.6-depup.0

package/react/hooks/useMutation.d.ts

@@ -0,0 +1,316 @@
+import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
+import type { ApolloCache, ApolloClient, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, InternalRefetchQueriesInclude, MaybeMasked, MutationFetchPolicy, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, Unmasked } from "@apollo/client";
+import type { IgnoreModifier } from "@apollo/client/cache";
+import type { NoInfer, Prettify } from "@apollo/client/utilities/internal";
+type MakeRequiredVariablesOptional<TVariables extends OperationVariables, TConfiguredVariables extends Partial<TVariables>> = Prettify<{
+    [K in keyof TVariables as K extends keyof TConfiguredVariables ? K : never]?: TVariables[K];
+} & Omit<TVariables, keyof TConfiguredVariables>>;
+export declare namespace useMutation {
+    interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = Partial<TVariables>> {
+        /**
+        * By providing either an object or a callback function that, when invoked after
+        * a mutation, allows you to return optimistic data and optionally skip updates
+        * via the `IGNORE` sentinel object, Apollo Client caches this temporary
+        * (and potentially incorrect) response until the mutation completes, enabling
+        * more responsive UI updates.
+        * 
+        * For more information, see [Optimistic mutation results](https://www.apollographql.com/docs/react/performance/optimistic-ui/).
+        * 
+        * @docGroup 3. Caching options
+        */
+        optimisticResponse?: Unmasked<NoInfer<TData>> | ((vars: TVariables, { IGNORE }: {
+            IGNORE: IgnoreModifier;
+        }) => Unmasked<NoInfer<TData>> | IgnoreModifier);
+        /**
+        * A `MutationQueryReducersMap`, which is map from query names to
+        * mutation query reducers. Briefly, this map defines how to incorporate the
+        * results of the mutation into the results of queries that are currently
+        * being watched by your application.
+        */
+        updateQueries?: MutationQueryReducersMap<TData>;
+        /**
+        * An array (or a function that _returns_ an array) that specifies which queries you want to refetch after the mutation occurs.
+        * 
+        * Each array value can be either:
+        * 
+        * - An object containing the `query` to execute, along with any `variables`
+        * 
+        * - A string indicating the operation name of the query to refetch
+        * 
+        * @docGroup 1. Operation options
+        */
+        refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+        /**
+        * If `true`, makes sure all queries included in `refetchQueries` are completed before the mutation is considered complete.
+        * 
+        * The default value is `false` (queries are refetched asynchronously).
+        * 
+        * @docGroup 1. Operation options
+        */
+        awaitRefetchQueries?: boolean;
+        /**
+        * A function used to update the Apollo Client cache after the mutation completes.
+        * 
+        * For more information, see [Updating the cache after a mutation](https://www.apollographql.com/docs/react/data/mutations#updating-the-cache-after-a-mutation).
+        * 
+        * @docGroup 3. Caching options
+        */
+        update?: MutationUpdaterFunction<TData, TVariables, TCache>;
+        /**
+        * Optional callback for intercepting queries whose cache data has been updated by the mutation, as well as any queries specified in the `refetchQueries: [...]` list passed to `client.mutate`.
+        * 
+        * Returning a `Promise` from `onQueryUpdated` will cause the final mutation `Promise` to await the returned `Promise`. Returning `false` causes the query to be ignored.
+        * 
+        * @docGroup 1. Operation options
+        */
+        onQueryUpdated?: OnQueryUpdated<any>;
+        /**
+        * Specifies how the mutation handles a response that returns both GraphQL errors and partial results.
+        * 
+        * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+        * 
+        * The default value is `none`, meaning that the mutation result includes error details but _not_ partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * An object containing all of the GraphQL variables your mutation requires to execute.
+        * 
+        * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+        * 
+        * @docGroup 1. Operation options
+        */
+        variables?: Partial<TVariables> & TConfiguredVariables;
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup 2. Networking options
+        */
+        context?: DefaultContext;
+        /**
+        * Provide `no-cache` if the mutation's result should _not_ be written to the Apollo Client cache.
+        * 
+        * The default value is `network-only` (which means the result _is_ written to the cache).
+        * 
+        * Unlike queries, mutations _do not_ support [fetch policies](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy) besides `network-only` and `no-cache`.
+        * 
+        * @docGroup 3. Caching options
+        */
+        fetchPolicy?: MutationFetchPolicy;
+        /**
+        * To avoid retaining sensitive information from mutation root field
+        * arguments, Apollo Client v3.4+ automatically clears any `ROOT_MUTATION`
+        * fields from the cache after each mutation finishes. If you need this
+        * information to remain in the cache, you can prevent the removal by passing
+        * `keepRootFields: true` to the mutation. `ROOT_MUTATION` result data are
+        * also passed to the mutation `update` function, so we recommend obtaining
+        * the results that way, rather than using this option, if possible.
+        */
+        keepRootFields?: boolean;
+        /**
+        * The instance of `ApolloClient` to use to execute the mutation.
+        * 
+        * By default, the instance that's passed down via context is used, but you can provide a different instance here.
+        * 
+        * @docGroup 2. Networking options
+        */
+        client?: ApolloClient;
+        /**
+        * If `true`, the in-progress mutation's associated component re-renders whenever the network status changes or a network error occurs.
+        * 
+        * The default value is `true`.
+        * 
+        * @docGroup 2. Networking options
+        */
+        notifyOnNetworkStatusChange?: boolean;
+        /**
+        * A callback function that's called when your mutation successfully completes with zero errors (or if `errorPolicy` is `ignore` and partial data is returned).
+        * 
+        * This function is passed the mutation's result `data` and any options passed to the mutation.
+        * 
+        * @docGroup 1. Operation options
+        */
+        onCompleted?: (data: MaybeMasked<TData>, clientOptions?: Options<TData, TVariables, TCache>) => void;
+        /**
+        * A callback function that's called when the mutation encounters one or more errors (unless `errorPolicy` is `ignore`).
+        * 
+        * This function is passed an [`ApolloError`](https://github.com/apollographql/apollo-client/blob/d96f4578f89b933c281bb775a39503f6cdb59ee8/src/errors/index.ts#L36-L39) object that contains either a `networkError` object or a `graphQLErrors` array, depending on the error(s) that occurred, as well as any options passed the mutation.
+        * 
+        * @docGroup 1. Operation options
+        */
+        onError?: (error: ErrorLike, clientOptions?: Options<TData, TVariables, TCache>) => void;
+    }
+    interface Result<TData = unknown> {
+        /**
+        * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+        * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+        * but not `data` or a network error is returned.
+        */
+        data: MaybeMasked<TData> | null | undefined;
+        /**
+        * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+        * 
+        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+        */
+        error: ErrorLike | undefined;
+        /**
+        * If `true`, the mutation is currently in flight.
+        */
+        loading: boolean;
+        /**
+        * If `true`, the mutation's mutate function has been called.
+        */
+        called: boolean;
+        /**
+        * The instance of Apollo Client that executed the mutation.
+        * 
+        * Can be useful for manually executing followup operations or writing data to the cache.
+        */
+        client: ApolloClient;
+        /**
+        * A function that you can call to reset the mutation's result to its initial, uncalled state.
+        */
+        reset: () => void;
+    }
+    type ResultTuple<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = [
+        mutate: MutationFunction<TData, TVariables, TCache>,
+        result: Result<TData>
+    ];
+    type MutationFunction<TData, TVariables extends OperationVariables, TCache extends ApolloCache = ApolloCache> = (...[options]: {} extends TVariables ? [
+        options?: MutationFunctionOptions<TData, TVariables, TCache> & {
+            /**
+            * An object containing all of the GraphQL variables your mutation requires to execute.
+            * 
+            * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+            * 
+            * @docGroup 1. Operation options
+            */
+            variables?: TVariables;
+        }
+    ] : [
+        options: MutationFunctionOptions<TData, TVariables, TCache> & {
+            /**
+            * An object containing all of the GraphQL variables your mutation requires to execute.
+            * 
+            * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+            * 
+            * @docGroup 1. Operation options
+            */
+            variables: TVariables;
+        }
+    ]) => Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+    type MutationFunctionOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = Options<TData, TVariables, TCache> & {
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup 2. Networking options
+        *      
+        *
+        * @remarks
+        * When provided as a callback function, the function is called with the
+        * value of `context` provided to the `useMutation` hook.
+        */
+        context?: DefaultContext | ((hookContext: DefaultContext | undefined) => DefaultContext);
+    };
+    namespace DocumentationTypes {
+        /**
+        * > Refer to the [Mutations](https://www.apollographql.com/docs/react/data/mutations/) section for a more in-depth overview of `useMutation`.
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { gql, useMutation } from "@apollo/client";
+        * 
+        * const ADD_TODO = gql`
+        *   mutation AddTodo($type: String!) {
+        *     addTodo(type: $type) {
+        *       id
+        *       type
+        *     }
+        *   }
+        * `;
+        * 
+        * function AddTodo() {
+        *   let input;
+        *   const [addTodo, { data }] = useMutation(ADD_TODO);
+        * 
+        *   return (
+        *     <div>
+        *       <form
+        *         onSubmit={(e) => {
+        *           e.preventDefault();
+        *           addTodo({ variables: { type: input.value } });
+        *           input.value = "";
+        *         }}
+        *       >
+        *         <input
+        *           ref={(node) => {
+        *             input = node;
+        *           }}
+        *         />
+        *         <button type="submit">Add Todo</button>
+        *       </form>
+        *     </div>
+        *   );
+        * }
+        * ```
+        * 
+        * @param mutation - A GraphQL mutation document parsed into an AST by `gql`.
+        * @param options - Options to control how the mutation is executed.
+        * @returns A tuple in the form of `[mutate, result]`
+        */
+        function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<TData, TVariables>): useMutation.ResultTuple<TData, TVariables>;
+    }
+}
+/**
+ * > Refer to the [Mutations](https://www.apollographql.com/docs/react/data/mutations/) section for a more in-depth overview of `useMutation`.
+ *
+ * @example
+ *
+ * ```jsx
+ * import { gql, useMutation } from "@apollo/client";
+ *
+ * const ADD_TODO = gql`
+ *   mutation AddTodo($type: String!) {
+ *     addTodo(type: $type) {
+ *       id
+ *       type
+ *     }
+ *   }
+ * `;
+ *
+ * function AddTodo() {
+ *   let input;
+ *   const [addTodo, { data }] = useMutation(ADD_TODO);
+ *
+ *   return (
+ *     <div>
+ *       <form
+ *         onSubmit={(e) => {
+ *           e.preventDefault();
+ *           addTodo({ variables: { type: input.value } });
+ *           input.value = "";
+ *         }}
+ *       >
+ *         <input
+ *           ref={(node) => {
+ *             input = node;
+ *           }}
+ *         />
+ *         <button type="submit">Add Todo</button>
+ *       </form>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param mutation - A GraphQL mutation document parsed into an AST by `gql`.
+ * @param options - Options to control how the mutation is executed.
+ * @returns A tuple in the form of `[mutate, result]`
+ */
+export declare function useMutation<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TConfiguredVariables extends Partial<TVariables> = {}>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<NoInfer<TData>, NoInfer<TVariables>, TCache, {
+    [K in keyof TConfiguredVariables]: K extends keyof TVariables ? TConfiguredVariables[K] : never;
+}>): useMutation.ResultTuple<TData, MakeRequiredVariablesOptional<TVariables, TConfiguredVariables>, TCache>;
+export {};
+//# sourceMappingURL=useMutation.d.ts.map

package/react/hooks/useMutation.js

@@ -0,0 +1,159 @@
+import { equal } from "@wry/equality";
+import * as React from "react";
+import { mergeOptions, preventUnhandledRejection, } from "@apollo/client/utilities/internal";
+import { useIsomorphicLayoutEffect } from "./internal/useIsomorphicLayoutEffect.js";
+import { useApolloClient } from "./useApolloClient.js";
+/**
+ * > Refer to the [Mutations](https://www.apollographql.com/docs/react/data/mutations/) section for a more in-depth overview of `useMutation`.
+ *
+ * @example
+ *
+ * ```jsx
+ * import { gql, useMutation } from "@apollo/client";
+ *
+ * const ADD_TODO = gql`
+ *   mutation AddTodo($type: String!) {
+ *     addTodo(type: $type) {
+ *       id
+ *       type
+ *     }
+ *   }
+ * `;
+ *
+ * function AddTodo() {
+ *   let input;
+ *   const [addTodo, { data }] = useMutation(ADD_TODO);
+ *
+ *   return (
+ *     <div>
+ *       <form
+ *         onSubmit={(e) => {
+ *           e.preventDefault();
+ *           addTodo({ variables: { type: input.value } });
+ *           input.value = "";
+ *         }}
+ *       >
+ *         <input
+ *           ref={(node) => {
+ *             input = node;
+ *           }}
+ *         />
+ *         <button type="submit">Add Todo</button>
+ *       </form>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param mutation - A GraphQL mutation document parsed into an AST by `gql`.
+ * @param options - Options to control how the mutation is executed.
+ * @returns A tuple in the form of `[mutate, result]`
+ */
+export function useMutation(mutation, options) {
+    const client = useApolloClient(options?.client);
+    const [result, setResult] = React.useState(() => createInitialResult(client));
+    const ref = React.useRef({
+        result,
+        mutationId: 0,
+        isMounted: true,
+        client,
+        mutation,
+        options,
+    });
+    useIsomorphicLayoutEffect(() => {
+        Object.assign(ref.current, { client, options, mutation });
+    });
+    const execute = React.useCallback((executeOptions = {}) => {
+        const { options, mutation } = ref.current;
+        const baseOptions = { ...options, mutation };
+        const client = executeOptions.client || ref.current.client;
+        const context = typeof executeOptions.context === "function" ?
+            executeOptions.context(options?.context)
+            : executeOptions.context;
+        if (!ref.current.result.loading && ref.current.isMounted) {
+            setResult((ref.current.result = {
+                loading: true,
+                error: undefined,
+                data: undefined,
+                called: true,
+                client,
+            }));
+        }
+        const mutationId = ++ref.current.mutationId;
+        const clientOptions = mergeOptions(baseOptions, {
+            ...executeOptions,
+            context,
+        });
+        return preventUnhandledRejection(client
+            .mutate(clientOptions)
+            .then((response) => {
+            const { data, error } = response;
+            const onError = executeOptions.onError || ref.current.options?.onError;
+            if (error && onError) {
+                onError(error, clientOptions);
+            }
+            if (mutationId === ref.current.mutationId) {
+                const result = {
+                    called: true,
+                    loading: false,
+                    data,
+                    error,
+                    client,
+                };
+                if (ref.current.isMounted &&
+                    !equal(ref.current.result, result)) {
+                    setResult((ref.current.result = result));
+                }
+            }
+            const onCompleted = executeOptions.onCompleted || ref.current.options?.onCompleted;
+            if (!error) {
+                onCompleted?.(response.data, clientOptions);
+            }
+            return response;
+        }, (error) => {
+            if (mutationId === ref.current.mutationId &&
+                ref.current.isMounted) {
+                const result = {
+                    loading: false,
+                    error,
+                    data: void 0,
+                    called: true,
+                    client,
+                };
+                if (!equal(ref.current.result, result)) {
+                    setResult((ref.current.result = result));
+                }
+            }
+            const onError = executeOptions.onError || ref.current.options?.onError;
+            if (onError) {
+                onError(error, clientOptions);
+            }
+            throw error;
+        }));
+    }, []);
+    const reset = React.useCallback(() => {
+        if (ref.current.isMounted) {
+            const result = createInitialResult(ref.current.client);
+            Object.assign(ref.current, { mutationId: 0, result });
+            setResult(result);
+        }
+    }, []);
+    React.useEffect(() => {
+        const current = ref.current;
+        current.isMounted = true;
+        return () => {
+            current.isMounted = false;
+        };
+    }, []);
+    return [execute, { reset, ...result }];
+}
+function createInitialResult(client) {
+    return {
+        data: undefined,
+        error: undefined,
+        called: false,
+        loading: false,
+        client,
+    };
+}
+//# sourceMappingURL=useMutation.js.map

package/react/hooks/useMutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMutation.js","sourceRoot":"","sources":["../../../src/react/hooks/useMutation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\nimport { equal } from \"@wry/equality\";\nimport * as React from \"react\";\n\nimport type {\n  ApolloCache,\n  ApolloClient,\n  DefaultContext,\n  DocumentNode,\n  ErrorLike,\n  ErrorPolicy,\n  InternalRefetchQueriesInclude,\n  MaybeMasked,\n  MutationFetchPolicy,\n  MutationQueryReducersMap,\n  MutationUpdaterFunction,\n  NormalizedExecutionResult,\n  OnQueryUpdated,\n  OperationVariables,\n  Unmasked,\n} from \"@apollo/client\";\nimport type { IgnoreModifier } from \"@apollo/client/cache\";\nimport type { NoInfer, Prettify } from \"@apollo/client/utilities/internal\";\nimport {\n  mergeOptions,\n  preventUnhandledRejection,\n} from \"@apollo/client/utilities/internal\";\n\nimport { useIsomorphicLayoutEffect } from \"./internal/useIsomorphicLayoutEffect.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\n\ntype MakeRequiredVariablesOptional<\n  TVariables extends OperationVariables,\n  TConfiguredVariables extends Partial<TVariables>,\n> = Prettify<\n  {\n    [K in keyof TVariables as K extends keyof TConfiguredVariables ? K\n    : never]?: TVariables[K];\n  } & Omit<TVariables, keyof TConfiguredVariables>\n>;\n\nexport declare namespace useMutation {\n  export interface Options<\n    TData = unknown,\n    TVariables extends OperationVariables = OperationVariables,\n    TCache extends ApolloCache = ApolloCache,\n    TConfiguredVariables extends Partial<TVariables> = Partial<TVariables>,\n  > {\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#optimisticResponse:member} */\n    optimisticResponse?:\n      | Unmasked<NoInfer<TData>>\n      | ((\n          vars: TVariables,\n          { IGNORE }: { IGNORE: IgnoreModifier }\n        ) => Unmasked<NoInfer<TData>> | IgnoreModifier);\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#updateQueries:member} */\n    updateQueries?: MutationQueryReducersMap<TData>;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#refetchQueries:member} */\n    refetchQueries?:\n      | ((\n          result: NormalizedExecutionResult<Unmasked<TData>>\n        ) => InternalRefetchQueriesInclude)\n      | InternalRefetchQueriesInclude;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#awaitRefetchQueries:member} */\n    awaitRefetchQueries?: boolean;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#update:member} */\n    update?: MutationUpdaterFunction<TData, TVariables, TCache>;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#onQueryUpdated:member} */\n    onQueryUpdated?: OnQueryUpdated<any>;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#errorPolicy:member} */\n    errorPolicy?: ErrorPolicy;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#variables:member} */\n    variables?: Partial<TVariables> & TConfiguredVariables;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#context:member} */\n    context?: DefaultContext;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#fetchPolicy:member} */\n    fetchPolicy?: MutationFetchPolicy;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#keepRootFields:member} */\n    keepRootFields?: boolean;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#client:member} */\n    client?: ApolloClient;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#notifyOnNetworkStatusChange:member} */\n    notifyOnNetworkStatusChange?: boolean;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#onCompleted:member} */\n    onCompleted?: (\n      data: MaybeMasked<TData>,\n      clientOptions?: Options<TData, TVariables, TCache>\n    ) => void;\n\n    /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#onError:member} */\n    onError?: (\n      error: ErrorLike,\n      clientOptions?: Options<TData, TVariables, TCache>\n    ) => void;\n  }\n\n  export interface Result<TData = unknown> {\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#data:member} */\n    data: MaybeMasked<TData> | null | undefined;\n\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#error:member} */\n    error: ErrorLike | undefined;\n\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#loading:member} */\n    loading: boolean;\n\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#called:member} */\n    called: boolean;\n\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#client:member} */\n    client: ApolloClient;\n\n    /** {@inheritDoc @apollo/client!MutationResultDocumentation#reset:member} */\n    reset: () => void;\n  }\n\n  export type ResultTuple<\n    TData,\n    TVariables extends OperationVariables,\n    TCache extends ApolloCache = ApolloCache,\n  > = [\n    mutate: MutationFunction<TData, TVariables, TCache>,\n    result: Result<TData>,\n  ];\n\n  export type MutationFunction<\n    TData,\n    TVariables extends OperationVariables,\n    TCache extends ApolloCache = ApolloCache,\n  > = (\n    ...[options]: {} extends TVariables ?\n      [\n        options?: MutationFunctionOptions<TData, TVariables, TCache> & {\n          /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#variables:member} */\n          variables?: TVariables;\n        },\n      ]\n    : [\n        options: MutationFunctionOptions<TData, TVariables, TCache> & {\n          /** {@inheritDoc @apollo/client!MutationOptionsDocumentation#variables:member} */\n          variables: TVariables;\n        },\n      ]\n  ) => Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;\n\n  export type MutationFunctionOptions<\n    TData = unknown,\n    TVariables extends OperationVariables = OperationVariables,\n    TCache extends ApolloCache = ApolloCache,\n  > = Options<TData, TVariables, TCache> & {\n    /**\n     * {@inheritDoc @apollo/client!MutationOptionsDocumentation#context:member}\n     *\n     * @remarks\n     * When provided as a callback function, the function is called with the\n     * value of `context` provided to the `useMutation` hook.\n     */\n    context?:\n      | DefaultContext\n      | ((hookContext: DefaultContext | undefined) => DefaultContext);\n  };\n\n  export namespace DocumentationTypes {\n    /** {@inheritDoc @apollo/client/react!useMutation:function(1)} */\n    export function useMutation<\n      TData = unknown,\n      TVariables extends OperationVariables = OperationVariables,\n    >(\n      mutation: DocumentNode | TypedDocumentNode<TData, TVariables>,\n      options?: useMutation.Options<TData, TVariables>\n    ): useMutation.ResultTuple<TData, TVariables>;\n  }\n}\n\n/**\n * > Refer to the [Mutations](https://www.apollographql.com/docs/react/data/mutations/) section for a more in-depth overview of `useMutation`.\n *\n * @example\n *\n * ```jsx\n * import { gql, useMutation } from \"@apollo/client\";\n *\n * const ADD_TODO = gql`\n *   mutation AddTodo($type: String!) {\n *     addTodo(type: $type) {\n *       id\n *       type\n *     }\n *   }\n * `;\n *\n * function AddTodo() {\n *   let input;\n *   const [addTodo, { data }] = useMutation(ADD_TODO);\n *\n *   return (\n *     <div>\n *       <form\n *         onSubmit={(e) => {\n *           e.preventDefault();\n *           addTodo({ variables: { type: input.value } });\n *           input.value = \"\";\n *         }}\n *       >\n *         <input\n *           ref={(node) => {\n *             input = node;\n *           }}\n *         />\n *         <button type=\"submit\">Add Todo</button>\n *       </form>\n *     </div>\n *   );\n * }\n * ```\n *\n * @param mutation - A GraphQL mutation document parsed into an AST by `gql`.\n * @param options - Options to control how the mutation is executed.\n * @returns A tuple in the form of `[mutate, result]`\n */\nexport function useMutation<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n  TCache extends ApolloCache = ApolloCache,\n  TConfiguredVariables extends Partial<TVariables> = {},\n>(\n  mutation: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options?: useMutation.Options<\n    NoInfer<TData>,\n    NoInfer<TVariables>,\n    TCache,\n    {\n      [K in keyof TConfiguredVariables]: K extends keyof TVariables ?\n        TConfiguredVariables[K]\n      : never;\n    }\n  >\n): useMutation.ResultTuple<\n  TData,\n  MakeRequiredVariablesOptional<TVariables, TConfiguredVariables>,\n  TCache\n> {\n  const client = useApolloClient(options?.client);\n  const [result, setResult] = React.useState<\n    Omit<useMutation.Result<TData>, \"reset\">\n  >(() => createInitialResult(client));\n\n  const ref = React.useRef({\n    result,\n    mutationId: 0,\n    isMounted: true,\n    client,\n    mutation,\n    options,\n  });\n\n  useIsomorphicLayoutEffect(() => {\n    Object.assign(ref.current, { client, options, mutation });\n  });\n\n  const execute = React.useCallback(\n    (\n      executeOptions: useMutation.MutationFunctionOptions<\n        TData,\n        TVariables,\n        TCache\n      > = {} as useMutation.MutationFunctionOptions<TData, TVariables, TCache>\n    ) => {\n      const { options, mutation } = ref.current;\n      const baseOptions = { ...options, mutation };\n      const client = executeOptions.client || ref.current.client;\n      const context =\n        typeof executeOptions.context === \"function\" ?\n          executeOptions.context(options?.context)\n        : executeOptions.context;\n\n      if (!ref.current.result.loading && ref.current.isMounted) {\n        setResult(\n          (ref.current.result = {\n            loading: true,\n            error: undefined,\n            data: undefined,\n            called: true,\n            client,\n          })\n        );\n      }\n\n      const mutationId = ++ref.current.mutationId;\n      const clientOptions = mergeOptions(baseOptions, {\n        ...executeOptions,\n        context,\n      } as any);\n\n      return preventUnhandledRejection(\n        client\n          .mutate(\n            clientOptions as ApolloClient.MutateOptions<\n              TData,\n              OperationVariables\n            >\n          )\n          .then(\n            (response) => {\n              const { data, error } = response;\n\n              const onError =\n                executeOptions.onError || ref.current.options?.onError;\n\n              if (error && onError) {\n                onError(error, clientOptions);\n              }\n\n              if (mutationId === ref.current.mutationId) {\n                const result = {\n                  called: true,\n                  loading: false,\n                  data,\n                  error,\n                  client,\n                };\n\n                if (\n                  ref.current.isMounted &&\n                  !equal(ref.current.result, result)\n                ) {\n                  setResult((ref.current.result = result));\n                }\n              }\n\n              const onCompleted =\n                executeOptions.onCompleted || ref.current.options?.onCompleted;\n\n              if (!error) {\n                onCompleted?.(response.data!, clientOptions);\n              }\n\n              return response;\n            },\n            (error) => {\n              if (\n                mutationId === ref.current.mutationId &&\n                ref.current.isMounted\n              ) {\n                const result = {\n                  loading: false,\n                  error,\n                  data: void 0,\n                  called: true,\n                  client,\n                };\n\n                if (!equal(ref.current.result, result)) {\n                  setResult((ref.current.result = result));\n                }\n              }\n\n              const onError =\n                executeOptions.onError || ref.current.options?.onError;\n\n              if (onError) {\n                onError(error, clientOptions);\n              }\n\n              throw error;\n            }\n          )\n      );\n    },\n    []\n  );\n\n  const reset = React.useCallback(() => {\n    if (ref.current.isMounted) {\n      const result = createInitialResult(ref.current.client);\n      Object.assign(ref.current, { mutationId: 0, result });\n      setResult(result);\n    }\n  }, []);\n\n  React.useEffect(() => {\n    const current = ref.current;\n    current.isMounted = true;\n\n    return () => {\n      current.isMounted = false;\n    };\n  }, []);\n\n  return [execute as any, { reset, ...result }];\n}\n\nfunction createInitialResult(client: ApolloClient) {\n  return {\n    data: undefined,\n    error: undefined,\n    called: false,\n    loading: false,\n    client,\n  };\n}\n"]}