@apollo/client 4.0.0-alpha.0 → 4.0.0-alpha.10

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

@@ -1,7 +1,201 @@
 import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
-import type { DocumentNode } from "graphql";
-import type { ApolloCache, DefaultContext, OperationVariables } from "@apollo/client/core";
-import type { MutationHookOptions, MutationTuple, NoInfer } from "@apollo/client/react";
+import type { ApolloCache, ApolloClient, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, FetchResult, InternalRefetchQueriesInclude, MaybeMasked, MutateResult, MutationFetchPolicy, MutationQueryReducersMap, MutationUpdaterFunction, OnQueryUpdated, OperationVariables, Unmasked } from "@apollo/client";
+import type { NoInfer } from "@apollo/client/utilities";
+import type { IgnoreModifier } from "../../cache/core/types/common.cjs";
+export declare namespace useMutation {
+    interface Options<TData = unknown, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> {
+        /**
+        * 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: FetchResult<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, TContext, 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?: TVariables;
+        /**
+        * 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?: TContext;
+        /**
+        * 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, TContext, 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, TContext, TCache>) => void;
+    }
+    interface Result<TData = unknown> {
+        /**
+        * The data returned from your mutation. Can be `undefined` if `ignoreResults` is `true`.
+        */
+        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, TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> = [
+        mutate: (options?: MutationFunctionOptions<TData, TVariables, TContext, TCache>) => Promise<MutateResult<MaybeMasked<TData>>>,
+        result: Result<TData>
+    ];
+    interface MutationFunctionOptions<TData = unknown, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache = ApolloCache> extends Options<TData, TVariables, TContext, TCache> {
+        /**
+        * A GraphQL document, often created with `gql` from the `graphql-tag` package, that contains a single mutation inside of it.
+        * 
+        * @docGroup
+        * 
+        * 1. Operation options
+        */
+        mutation?: DocumentNode | TypedDocumentNode<TData, TVariables>;
+    }
+}
 /**
  *
  *
@@ -49,5 +243,5 @@ import type { MutationHookOptions, MutationTuple, NoInfer } from "@apollo/client
  * @param options - Options to control how the mutation is executed.
  * @returns A tuple in the form of `[mutate, result]`
  */
-export declare function useMutation<TData = any, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: MutationHookOptions<NoInfer<TData>, NoInfer<TVariables>, TContext, TCache>): MutationTuple<TData, TVariables, TContext, TCache>;
+export declare function useMutation<TData = unknown, TVariables = OperationVariables, TContext = DefaultContext, TCache extends ApolloCache = ApolloCache>(mutation: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useMutation.Options<NoInfer<TData>, NoInfer<TVariables>, TContext, TCache>): useMutation.ResultTuple<TData, TVariables, TContext, TCache>;
 //# sourceMappingURL=useMutation.d.cts.map

package/__cjs/react/hooks/useQuery.cjs

@@ -13,20 +13,13 @@ const tslib_1 = require("tslib");
  * options
  * watchQueryOptions
  * makeWatchQueryOptions
- * isSSRAllowed
- * disableNetworkFetches
- * renderPromises
- * isSyncSSR
  */
 /** */
 const equality_1 = require("@wry/equality");
-const React = tslib_1.__importStar(require("rehackt"));
+const React = tslib_1.__importStar(require("react"));
 const rxjs_1 = require("rxjs");
-const core_1 = require("@apollo/client/core");
-const context_1 = require("@apollo/client/react/context");
-const parser_1 = require("@apollo/client/react/parser");
+const client_1 = require("@apollo/client");
 const utilities_1 = require("@apollo/client/utilities");
-const utilities_2 = require("@apollo/client/utilities");
 const index_js_1 = require("./internal/index.cjs");
 const useApolloClient_js_1 = require("./useApolloClient.cjs");
 const useSyncExternalStore_js_1 = require("./useSyncExternalStore.cjs");
@@ -65,97 +58,99 @@ const lastWatchOptions = Symbol();
  * @param options - Options to control how the query is executed.
  * @returns Query result object
  */
-function useQuery(query, options = {}) {
+function useQuery(query, ...[options]) {
+    "use no memo";
     return (0, index_js_1.wrapHook)("useQuery", 
     // eslint-disable-next-line react-compiler/react-compiler
     useQuery_, (0, useApolloClient_js_1.useApolloClient)(options && options.client))(query, options);
 }
-function useQuery_(query, options) {
-    const result = useQueryInternals(query, options);
-    const obsQueryFields = React.useMemo(() => bindObservableMethods(result.observable), [result.observable]);
-    return React.useMemo(() => ({ ...result, ...obsQueryFields }), [result, obsQueryFields]);
-}
-function useInternalState(client, query, options, renderPromises, makeWatchQueryOptions) {
-    function createInternalState(previous) {
-        (0, parser_1.verifyDocumentType)(query, parser_1.DocumentType.Query);
-        const internalState = {
+function useQuery_(query, options = {}) {
+    const client = (0, useApolloClient_js_1.useApolloClient)(options.client);
+    const { skip, ssr, ...opts } = options;
+    const watchQueryOptions = (0, utilities_1.mergeOptions)(client.defaultOptions.watchQuery, { ...opts, query });
+    if (skip) {
+        // When skipping, we set watchQueryOptions.fetchPolicy initially to
+        // "standby", but we also need/want to preserve the initial non-standby
+        // fetchPolicy that would have been used if not skipping.
+        watchQueryOptions.initialFetchPolicy =
+            options.initialFetchPolicy || options.fetchPolicy;
+        watchQueryOptions.fetchPolicy = "standby";
+    }
+    function createState(previous) {
+        const observable = client_1.ObservableQuery["inactiveOnCreation"].withValue(true, () => client.watchQuery(watchQueryOptions));
+        return {
             client,
             query,
-            observable: 
-            // See if there is an existing observable that was used to fetch the same
-            // data and if so, use it instead since it will contain the proper queryId
-            // to fetch the result set. This is used during SSR.
-            (renderPromises &&
-                renderPromises.getSSRObservable(makeWatchQueryOptions())) ||
-                client.watchQuery(getObsQueryOptions(void 0, client, options, makeWatchQueryOptions())),
+            observable,
             resultData: {
+                current: observable.getCurrentResult(),
                 // Reuse previousData from previous InternalState (if any) to provide
                 // continuity of previousData even if/when the query or client changes.
-                previousData: previous?.resultData.current?.data,
+                previousData: previous?.resultData.current.data,
             },
         };
-        return internalState;
     }
-    let [internalState, updateInternalState] = React.useState(createInternalState);
-    if (client !== internalState.client || query !== internalState.query) {
+    let [state, setState] = React.useState(createState);
+    if (client !== state.client || query !== state.query) {
         // If the client or query have changed, we need to create a new InternalState.
         // This will trigger a re-render with the new state, but it will also continue
         // to run the current render function to completion.
         // Since we sometimes trigger some side-effects in the render function, we
         // re-assign `state` to the new state to ensure that those side-effects are
         // triggered with the new state.
-        const newInternalState = createInternalState(internalState);
-        updateInternalState(newInternalState);
-        return newInternalState;
+        setState((state = createState(state)));
     }
-    return internalState;
-}
-function useQueryInternals(query, options) {
-    const client = (0, useApolloClient_js_1.useApolloClient)(options.client);
-    const renderPromises = React.useContext((0, context_1.getApolloContext)()).renderPromises;
-    const isSyncSSR = !!renderPromises;
-    const disableNetworkFetches = client.disableNetworkFetches;
-    const ssrAllowed = options.ssr !== false && !options.skip;
-    const makeWatchQueryOptions = createMakeWatchQueryOptions(client, query, options, isSyncSSR);
-    const { observable, resultData } = useInternalState(client, query, options, renderPromises, makeWatchQueryOptions);
-    const watchQueryOptions = makeWatchQueryOptions(observable);
+    const { observable, resultData } = state;
+    useInitialFetchPolicyIfNecessary(watchQueryOptions, observable);
     useResubscribeIfNecessary(resultData, // might get mutated during render
     observable, // might get mutated during render
-    client, options, watchQueryOptions);
-    useRegisterSSRObservable(observable, renderPromises, ssrAllowed);
-    const result = useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR);
-    return result;
-}
-function useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, isSyncSSR) {
-    const resultOverride = ((isSyncSSR || disableNetworkFetches) &&
-        options.ssr === false &&
-        !options.skip) ?
-        // If SSR has been explicitly disabled, and this function has been called
-        // on the server side, return the default loading state.
-        ssrDisabledResult
-        : options.skip || watchQueryOptions.fetchPolicy === "standby" ?
-            // When skipping a query (ie. we're not querying for data but still want to
-            // render children), make sure the `data` is cleared out and `loading` is
-            // set to `false` (since we aren't loading anything).
-            //
-            // NOTE: We no longer think this is the correct behavior. Skipping should
-            // not automatically set `data` to `undefined`, but instead leave the
-            // previous data in place. In other words, skipping should not mandate that
-            // previously received data is all of a sudden removed. Unfortunately,
-            // changing this is breaking, so we'll have to wait until Apollo Client 4.0
-            // to address this.
-            skipStandbyResult
-            : void 0;
+    watchQueryOptions);
+    const ssrDisabledOverride = (0, useSyncExternalStore_js_1.useSyncExternalStore)(() => () => { }, () => void 0, () => (ssr === false ? useQuery.ssrDisabledResult : void 0));
+    const resultOverride = skip || watchQueryOptions.fetchPolicy === "standby" ?
+        // When skipping a query (ie. we're not querying for data but still want to
+        // render children), make sure the `data` is cleared out and `loading` is
+        // set to `false` (since we aren't loading anything).
+        //
+        // NOTE: We no longer think this is the correct behavior. Skipping should
+        // not automatically set `data` to `undefined`, but instead leave the
+        // previous data in place. In other words, skipping should not mandate that
+        // previously received data is all of a sudden removed. Unfortunately,
+        // changing this is breaking, so we'll have to wait until Apollo Client 4.0
+        // to address this.
+        useQuery.skipStandbyResult
+        : ssrDisabledOverride;
+    const result = useResultSubscription(observable, resultData, resultOverride);
+    const obsQueryFields = React.useMemo(() => ({
+        refetch: observable.refetch.bind(observable),
+        fetchMore: observable.fetchMore.bind(observable),
+        updateQuery: observable.updateQuery.bind(observable),
+        startPolling: observable.startPolling.bind(observable),
+        stopPolling: observable.stopPolling.bind(observable),
+        subscribeToMore: observable.subscribeToMore.bind(observable),
+    }), [observable]);
     const previousData = resultData.previousData;
-    const currentResultOverride = React.useMemo(() => resultOverride &&
-        toQueryResult(resultOverride, previousData, observable, client), [client, observable, resultOverride, previousData]);
+    return React.useMemo(() => {
+        const { data, partial, ...rest } = result;
+        return {
+            data, // Ensure always defined, even if result.data is missing.
+            ...rest,
+            client: client,
+            observable: observable,
+            variables: observable.variables,
+            previousData,
+            ...obsQueryFields,
+        };
+    }, [result, client, observable, previousData, obsQueryFields]);
+}
+function useInitialFetchPolicyIfNecessary(watchQueryOptions, observable) {
+    "use no memo";
+    if (!watchQueryOptions.fetchPolicy) {
+        watchQueryOptions.fetchPolicy = observable.options.initialFetchPolicy;
+    }
+}
+function useResultSubscription(observable, resultData, resultOverride) {
+    "use no memo";
     return (0, useSyncExternalStore_js_1.useSyncExternalStore)(React.useCallback((handleStoreChange) => {
-        // reference `disableNetworkFetches` here to ensure that the rules of hooks
-        // keep it as a dependency of this effect, even though it's not used
-        disableNetworkFetches;
-        if (isSyncSSR) {
-            return () => { };
-        }
         const subscription = observable
             // We use the asapScheduler here to prevent issues with trying to
             // update in the middle of a render. `reobserve` is kicked off in the
@@ -176,7 +171,12 @@ function useObservableSubscriptionResult(resultData, observable, client, options
                 (0, equality_1.equal)(previousResult.error, result.error)) {
                 return;
             }
-            setResult(result, resultData, observable, client, handleStoreChange);
+            if (previousResult && previousResult.data) {
+                // eslint-disable-next-line react-compiler/react-compiler
+                resultData.previousData = previousResult.data;
+            }
+            resultData.current = result;
+            handleStoreChange();
         });
         // Do the "unsubscribe" with a short delay.
         // This way, an existing subscription can be reused without an additional
@@ -185,16 +185,7 @@ function useObservableSubscriptionResult(resultData, observable, client, options
         return () => {
             setTimeout(() => subscription.unsubscribe());
         };
-    }, [disableNetworkFetches, isSyncSSR, observable, resultData, client]), () => currentResultOverride || getCurrentResult(resultData, observable, client), () => currentResultOverride || getCurrentResult(resultData, observable, client));
-}
-function useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {
-    if (renderPromises && ssrAllowed) {
-        renderPromises.registerSSRObservable(observable);
-        if (observable.getCurrentResult().loading) {
-            // TODO: This is a legacy API which could probably be cleaned up
-            renderPromises.addObservableQueryPromise(observable);
-        }
-    }
+    }, [observable, resultData]), () => resultOverride || resultData.current, () => resultOverride || resultData.current);
 }
 // this hook is not compatible with any rules of React, and there's no good way to rewrite it.
 // it should stay a separate hook that will not be optimized by the compiler
@@ -202,7 +193,8 @@ function useResubscribeIfNecessary(
 /** this hook will mutate properties on `resultData` */
 resultData, 
 /** this hook will mutate properties on `observable` */
-observable, client, options, watchQueryOptions) {
+observable, watchQueryOptions) {
+    "use no memo";
     if (observable[lastWatchOptions] &&
         !(0, equality_1.equal)(observable[lastWatchOptions], watchQueryOptions)) {
         // Though it might be tempting to postpone this reobserve call to the
@@ -213,139 +205,28 @@ observable, client, options, watchQueryOptions) {
         // subscriptions, though it does feel less than ideal that reobserve
         // (potentially) kicks off a network request (for example, when the
         // variables have changed), which is technically a side-effect.
-        observable.reobserve(getObsQueryOptions(observable, client, options, watchQueryOptions));
+        observable.reobserve(watchQueryOptions);
         // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,
         // but save the current data as this.previousData, just like setResult
         // usually does.
         resultData.previousData =
-            resultData.current?.data || resultData.previousData;
-        resultData.current = void 0;
+            resultData.current.data || resultData.previousData;
+        resultData.current = observable.getCurrentResult();
     }
     observable[lastWatchOptions] = watchQueryOptions;
 }
-/*
- * A function to massage options before passing them to ObservableQuery.
- * This is two-step curried because we want to reuse the `make` function,
- * but the `observable` might differ between calls to `make`.
- */
-function createMakeWatchQueryOptions(client, query, { skip, ssr, defaultOptions, 
-// The above options are useQuery-specific, so this ...otherOptions spread
-// makes otherOptions almost a WatchQueryOptions object, except for the
-// query property that we add below.
-...otherOptions } = {}, isSyncSSR) {
-    return (observable) => {
-        // This Object.assign is safe because otherOptions is a fresh ...rest object
-        // that did not exist until just now, so modifications are still allowed.
-        const watchQueryOptions = Object.assign(otherOptions, { query });
-        if (isSyncSSR &&
-            (watchQueryOptions.fetchPolicy === "network-only" ||
-                watchQueryOptions.fetchPolicy === "cache-and-network")) {
-            // this behavior was added to react-apollo without explanation in this PR
-            // https://github.com/apollographql/react-apollo/pull/1579
-            watchQueryOptions.fetchPolicy = "cache-first";
-        }
-        if (!watchQueryOptions.variables) {
-            watchQueryOptions.variables = {};
-        }
-        if (skip) {
-            // When skipping, we set watchQueryOptions.fetchPolicy initially to
-            // "standby", but we also need/want to preserve the initial non-standby
-            // fetchPolicy that would have been used if not skipping.
-            watchQueryOptions.initialFetchPolicy =
-                watchQueryOptions.initialFetchPolicy ||
-                    watchQueryOptions.fetchPolicy ||
-                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
-            watchQueryOptions.fetchPolicy = "standby";
-        }
-        else if (!watchQueryOptions.fetchPolicy) {
-            watchQueryOptions.fetchPolicy =
-                observable?.options.initialFetchPolicy ||
-                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);
-        }
-        return watchQueryOptions;
-    };
-}
-function getObsQueryOptions(observable, client, queryHookOptions, watchQueryOptions) {
-    const toMerge = [];
-    const globalDefaults = client.defaultOptions.watchQuery;
-    if (globalDefaults)
-        toMerge.push(globalDefaults);
-    if (queryHookOptions.defaultOptions) {
-        toMerge.push(queryHookOptions.defaultOptions);
-    }
-    // We use compact rather than mergeOptions for this part of the merge,
-    // because we want watchQueryOptions.variables (if defined) to replace
-    // this.observable.options.variables whole. This replacement allows
-    // removing variables by removing them from the variables input to
-    // useQuery. If the variables were always merged together (rather than
-    // replaced), there would be no way to remove existing variables.
-    // However, the variables from options.defaultOptions and globalDefaults
-    // (if provided) should be merged, to ensure individual defaulted
-    // variables always have values, if not otherwise defined in
-    // observable.options or watchQueryOptions.
-    toMerge.push((0, utilities_1.compact)(observable && observable.options, watchQueryOptions));
-    return toMerge.reduce(utilities_2.mergeOptions);
-}
-function setResult(nextResult, resultData, observable, client, forceUpdate) {
-    const previousResult = resultData.current;
-    if (previousResult && previousResult.data) {
-        resultData.previousData = previousResult.data;
-    }
-    resultData.current = toQueryResult(nextResult, resultData.previousData, observable, client);
-    // Calling state.setResult always triggers an update, though some call sites
-    // perform additional equality checks before committing to an update.
-    forceUpdate();
-}
-function getCurrentResult(resultData, observable, client) {
-    // Using this.result as a cache ensures getCurrentResult continues returning
-    // the same (===) result object, unless state.setResult has been called, or
-    // we're doing server rendering and therefore override the result below.
-    if (!resultData.current) {
-        setResult(observable.getCurrentResult(), resultData, observable, client, () => { });
-    }
-    return resultData.current;
-}
-function getDefaultFetchPolicy(queryHookDefaultOptions, clientDefaultOptions) {
-    return (queryHookDefaultOptions?.fetchPolicy ||
-        clientDefaultOptions?.watchQuery?.fetchPolicy ||
-        "cache-first");
-}
-function toQueryResult(result, previousData, observable, client) {
-    const { data, partial, ...resultWithoutPartial } = result;
-    const queryResult = {
-        data, // Ensure always defined, even if result.data is missing.
-        ...resultWithoutPartial,
-        client: client,
-        observable: observable,
-        variables: observable.variables,
-        called: result !== ssrDisabledResult && result !== skipStandbyResult,
-        previousData,
-    };
-    return queryResult;
-}
-const ssrDisabledResult = (0, utilities_1.maybeDeepFreeze)({
+useQuery.ssrDisabledResult = (0, utilities_1.maybeDeepFreeze)({
     loading: true,
     data: void 0,
     error: void 0,
-    networkStatus: core_1.NetworkStatus.loading,
+    networkStatus: client_1.NetworkStatus.loading,
     partial: true,
 });
-const skipStandbyResult = (0, utilities_1.maybeDeepFreeze)({
+useQuery.skipStandbyResult = (0, utilities_1.maybeDeepFreeze)({
     loading: false,
     data: void 0,
     error: void 0,
-    networkStatus: core_1.NetworkStatus.ready,
+    networkStatus: client_1.NetworkStatus.ready,
     partial: true,
 });
-function bindObservableMethods(observable) {
-    return {
-        refetch: observable.refetch.bind(observable),
-        reobserve: observable.reobserve.bind(observable),
-        fetchMore: observable.fetchMore.bind(observable),
-        updateQuery: observable.updateQuery.bind(observable),
-        startPolling: observable.startPolling.bind(observable),
-        stopPolling: observable.stopPolling.bind(observable),
-        subscribeToMore: observable.subscribeToMore.bind(observable),
-    };
-}
 //# sourceMappingURL=useQuery.cjs.map