@depup/apollo__client 4.1.6-depup.0

package/react/hooks/useQuery.js

@@ -0,0 +1,215 @@
+/**
+ * Function parameters in this file try to follow a common order for the sake of
+ * readability and consistency. The order is as follows:
+ *
+ * resultData
+ * observable
+ * client
+ * query
+ * options
+ * watchQueryOptions
+ * makeWatchQueryOptions
+ */
+/**  */
+import { equal } from "@wry/equality";
+import * as React from "react";
+import { asapScheduler, observeOn } from "rxjs";
+import { NetworkStatus } from "@apollo/client";
+import { maybeDeepFreeze, mergeOptions, variablesUnknownSymbol, } from "@apollo/client/utilities/internal";
+import { skipToken } from "./constants.js";
+import { useDeepMemo, wrapHook } from "./internal/index.js";
+import { useApolloClient } from "./useApolloClient.js";
+import { useSyncExternalStore } from "./useSyncExternalStore.js";
+const lastWatchOptions = Symbol();
+export function useQuery(query, ...[options]) {
+    "use no memo";
+    return wrapHook("useQuery", useQuery_, useApolloClient(typeof options === "object" ? options.client : undefined))(query, options);
+}
+function useQuery_(query, options = {}) {
+    const client = useApolloClient(typeof options === "object" ? options.client : undefined);
+    const { ssr } = typeof options === "object" ? options : {};
+    const watchQueryOptions = useOptions(query, options, client.defaultOptions.watchQuery);
+    function createState(previous) {
+        const observable = client.watchQuery(watchQueryOptions);
+        return {
+            client,
+            query,
+            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,
+                variables: observable.variables,
+            },
+        };
+    }
+    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.
+        setState((state = createState(state)));
+    }
+    const { observable, resultData } = state;
+    useInitialFetchPolicyIfNecessary(watchQueryOptions, observable);
+    useResubscribeIfNecessary(resultData, // might get mutated during render
+    observable, // might get mutated during render
+    watchQueryOptions);
+    const result = useResult(observable, resultData, ssr);
+    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;
+    return React.useMemo(() => {
+        const { partial, ...rest } = result;
+        return {
+            ...rest,
+            client,
+            observable,
+            variables: observable.variables,
+            previousData,
+            ...obsQueryFields,
+        };
+    }, [result, client, observable, previousData, obsQueryFields]);
+}
+const fromSkipToken = Symbol();
+function useOptions(query, options, defaultOptions) {
+    return useDeepMemo(() => {
+        if (options === skipToken) {
+            const opts = {
+                ...mergeOptions(defaultOptions, {
+                    query,
+                    fetchPolicy: "standby",
+                }),
+                [variablesUnknownSymbol]: true,
+            };
+            opts[fromSkipToken] = true;
+            return opts;
+        }
+        const watchQueryOptions = mergeOptions(defaultOptions, { ...options, query });
+        if (options.skip) {
+            watchQueryOptions.initialFetchPolicy =
+                options.initialFetchPolicy || options.fetchPolicy;
+            watchQueryOptions.fetchPolicy = "standby";
+        }
+        return watchQueryOptions;
+    }, [query, options, defaultOptions]);
+}
+function useInitialFetchPolicyIfNecessary(watchQueryOptions, observable) {
+    "use no memo";
+    if (!watchQueryOptions.fetchPolicy) {
+        watchQueryOptions.fetchPolicy = observable.options.initialFetchPolicy;
+    }
+}
+function useResult(observable, resultData, ssr) {
+    "use no memo";
+    const fetchPolicy = observable.options.fetchPolicy;
+    return useSyncExternalStore(React.useCallback((handleStoreChange) => {
+        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
+            // middle of a render and because RxJS emits values synchronously,
+            // its possible for this `handleStoreChange` to be called in that same
+            // render. This allows the render to complete before trying to emit a
+            // new value.
+            .pipe(observeOn(asapScheduler))
+            .subscribe((result) => {
+            const previous = resultData.current;
+            if (
+            // Avoid rerendering if the result is the same
+            equal(previous, result) &&
+                // Force rerender if the value was emitted because variables
+                // changed, such as when calling `refetch(newVars)` which returns
+                // the same data when `notifyOnNetworkStatusChange` is `false`.
+                equal(resultData.variables, observable.variables)) {
+                return;
+            }
+            resultData.variables = observable.variables;
+            if (previous.data && !equal(previous.data, result.data)) {
+                resultData.previousData = previous.data;
+            }
+            resultData.current = result;
+            handleStoreChange();
+        });
+        // Do the "unsubscribe" with a short delay.
+        // This way, an existing subscription can be reused without an additional
+        // request if "unsubscribe"  and "resubscribe" to the same ObservableQuery
+        // happen in very fast succession.
+        return () => {
+            setTimeout(() => subscription.unsubscribe());
+        };
+    }, [observable, resultData]), () => resultData.current, () => ((fetchPolicy !== "standby" && ssr === false) ||
+        fetchPolicy === "no-cache") ?
+        useQuery.ssrDisabledResult
+        : 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
+function useResubscribeIfNecessary(
+/** this hook will mutate properties on `resultData` */
+resultData, 
+/** this hook will mutate properties on `observable` */
+observable, watchQueryOptions) {
+    "use no memo";
+    if (observable[lastWatchOptions] &&
+        !equal(observable[lastWatchOptions], watchQueryOptions)) {
+        // If skipToken was used to generate options, we won't know the correct
+        // initialFetchPolicy until the hook is rerendered with real options, so we
+        // set it the next time we get real options
+        if (observable[lastWatchOptions][fromSkipToken] &&
+            !watchQueryOptions.initialFetchPolicy) {
+            watchQueryOptions.initialFetchPolicy =
+                watchQueryOptions.fetchPolicy;
+        }
+        // Though it might be tempting to postpone this reobserve call to the
+        // useEffect block, we need getCurrentResult to return an appropriate
+        // loading:true result synchronously (later within the same call to
+        // useQuery). Since we already have this.observable here (not true for
+        // the very first call to useQuery), we are not initiating any new
+        // 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.
+        if (shouldReobserve(observable[lastWatchOptions], watchQueryOptions)) {
+            observable.reobserve(watchQueryOptions);
+        }
+        else {
+            observable.applyOptions(watchQueryOptions);
+        }
+        // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,
+        // but save the current data as this.previousData, just like setResult
+        // usually does.
+        const result = observable.getCurrentResult();
+        if (!equal(result.data, resultData.current.data)) {
+            resultData.previousData = (resultData.current.data ||
+                resultData.previousData);
+        }
+        resultData.current = result;
+        resultData.variables = observable.variables;
+    }
+    observable[lastWatchOptions] = watchQueryOptions;
+}
+function shouldReobserve(previousOptions, options) {
+    return (previousOptions.query !== options.query ||
+        !equal(previousOptions.variables, options.variables) ||
+        (previousOptions.fetchPolicy !== options.fetchPolicy &&
+            (options.fetchPolicy === "standby" ||
+                previousOptions.fetchPolicy === "standby")));
+}
+useQuery.ssrDisabledResult = maybeDeepFreeze({
+    loading: true,
+    data: void 0,
+    dataState: "empty",
+    error: void 0,
+    networkStatus: NetworkStatus.loading,
+    partial: true,
+});
+//# sourceMappingURL=useQuery.js.map

package/react/hooks/useQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.js","sourceRoot":"","sources":["../../../src/react/hooks/useQuery.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Function parameters in this file try to follow a common order for the sake of\n * readability and consistency. The order is as follows:\n *\n * resultData\n * observable\n * client\n * query\n * options\n * watchQueryOptions\n * makeWatchQueryOptions\n */\n/**  */\nimport { equal } from \"@wry/equality\";\nimport * as React from \"react\";\nimport { asapScheduler, observeOn } from \"rxjs\";\n\nimport type {\n  DataState,\n  DefaultContext,\n  DocumentNode,\n  ErrorLike,\n  ErrorPolicy,\n  GetDataState,\n  InternalTypes,\n  ObservableQuery,\n  OperationVariables,\n  RefetchWritePolicy,\n  SubscribeToMoreFunction,\n  TypedDocumentNode,\n  UpdateQueryMapFn,\n  WatchQueryFetchPolicy,\n} from \"@apollo/client\";\nimport type { ApolloClient } from \"@apollo/client\";\nimport { NetworkStatus } from \"@apollo/client\";\nimport type { MaybeMasked } from \"@apollo/client/masking\";\nimport type {\n  DocumentationTypes as UtilityDocumentationTypes,\n  NoInfer,\n  VariablesOption,\n} from \"@apollo/client/utilities/internal\";\nimport {\n  maybeDeepFreeze,\n  mergeOptions,\n  variablesUnknownSymbol,\n} from \"@apollo/client/utilities/internal\";\n\nimport type { SkipToken } from \"./constants.js\";\nimport { skipToken } from \"./constants.js\";\nimport { useDeepMemo, wrapHook } from \"./internal/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\n\nexport declare namespace useQuery {\n  import _self = useQuery;\n  export namespace Base {\n    export interface Options<\n      TData = unknown,\n      TVariables extends OperationVariables = OperationVariables,\n    > {\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#fetchPolicy:member} */\n      fetchPolicy?: WatchQueryFetchPolicy;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#nextFetchPolicy:member} */\n      nextFetchPolicy?:\n        | WatchQueryFetchPolicy\n        | ((\n            this: ApolloClient.WatchQueryOptions<TData, TVariables>,\n            currentFetchPolicy: WatchQueryFetchPolicy,\n            context: InternalTypes.NextFetchPolicyContext<TData, TVariables>\n          ) => WatchQueryFetchPolicy);\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#initialFetchPolicy:member} */\n\n      initialFetchPolicy?: WatchQueryFetchPolicy;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#refetchWritePolicy:member} */\n      refetchWritePolicy?: RefetchWritePolicy;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#errorPolicy:member} */\n      errorPolicy?: ErrorPolicy;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#pollInterval:member} */\n      pollInterval?: number;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#notifyOnNetworkStatusChange:member} */\n      notifyOnNetworkStatusChange?: boolean;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#returnPartialData:member} */\n      returnPartialData?: boolean;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#skipPollAttempt:member} */\n      skipPollAttempt?: () => boolean;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#ssr:member} */\n      ssr?: boolean;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#client:member} */\n      client?: ApolloClient;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#context:member} */\n      context?: DefaultContext;\n\n      /** {@inheritDoc @apollo/client!QueryOptionsDocumentation#skip:member} */\n      skip?: boolean;\n    }\n  }\n  export type Options<\n    TData = unknown,\n    TVariables extends OperationVariables = OperationVariables,\n  > = Base.Options<TData, TVariables> & VariablesOption<TVariables>;\n\n  export namespace DocumentationTypes {\n    namespace useQuery {\n      export interface Options<\n        TData = unknown,\n        TVariables extends OperationVariables = OperationVariables,\n      > extends Base.Options<TData, TVariables>,\n          UtilityDocumentationTypes.VariableOptions<TVariables> {}\n    }\n  }\n\n  export namespace Base {\n    export interface Result<\n      TData = unknown,\n      TVariables extends OperationVariables = OperationVariables,\n      TReturnVariables extends OperationVariables = TVariables,\n    > {\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#client:member} */\n      client: ApolloClient;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#observable:member} */\n      observable: ObservableQuery<TData, TVariables>;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#previousData:member} */\n      previousData?: MaybeMasked<TData>;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#error:member} */\n      error?: ErrorLike;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#loading:member} */\n      loading: boolean;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#networkStatus:member} */\n      networkStatus: NetworkStatus;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#startPolling:member} */\n      startPolling: (pollInterval: number) => void;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#stopPolling:member} */\n      stopPolling: () => void;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#subscribeToMore:member} */\n      subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#updateQuery:member} */\n      updateQuery: (mapFn: UpdateQueryMapFn<TData, TVariables>) => void;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#refetch:member} */\n      refetch: (\n        variables?: Partial<TVariables>\n      ) => Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#variables:member} */\n      variables: TReturnVariables;\n\n      /** {@inheritDoc @apollo/client!QueryResultDocumentation#fetchMore:member} */\n      fetchMore: <\n        TFetchData = TData,\n        TFetchVars extends OperationVariables = TVariables,\n      >(\n        fetchMoreOptions: ObservableQuery.FetchMoreOptions<\n          TData,\n          TVariables,\n          TFetchData,\n          TFetchVars\n        >\n      ) => Promise<ApolloClient.QueryResult<MaybeMasked<TFetchData>>>;\n    }\n  }\n  export type Result<\n    TData = unknown,\n    TVariables extends OperationVariables = OperationVariables,\n    TStates extends\n      DataState<TData>[\"dataState\"] = DataState<TData>[\"dataState\"],\n    TReturnVariables extends OperationVariables = TVariables,\n  > = Base.Result<TData, TVariables, TReturnVariables> &\n    GetDataState<MaybeMasked<TData>, TStates>;\n\n  export namespace DocumentationTypes {\n    namespace useQuery {\n      export interface Result<\n        TData = unknown,\n        TVariables extends OperationVariables = OperationVariables,\n      > extends Base.Result<TData, TVariables>,\n          UtilityDocumentationTypes.DataState<TData> {}\n    }\n  }\n\n  export namespace DocumentationTypes {\n    /** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\n    export function useQuery<\n      TData = unknown,\n      TVariables extends OperationVariables = OperationVariables,\n    >(\n      query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n      options: useQuery.Options<TData, TVariables>\n    ): useQuery.Result<TData, TVariables>;\n  }\n}\n\nconst lastWatchOptions = Symbol();\n\ninterface ObsQueryWithMeta<TData, TVariables extends OperationVariables>\n  extends ObservableQuery<TData, TVariables> {\n  [lastWatchOptions]?: Readonly<\n    ApolloClient.WatchQueryOptions<TData, TVariables>\n  >;\n}\n\ninterface InternalResult<TData> {\n  // These members are populated by getCurrentResult and setResult, and it's\n  // okay/normal for them to be initially undefined.\n  current: ObservableQuery.Result<TData>;\n  previousData?: undefined | MaybeMasked<TData>;\n\n  // Track current variables separately in case a call to e.g. `refetch(newVars)`\n  // causes an emit that is deeply equal to the current result. This lets us\n  // compare if we should force rerender due to changed variables\n  variables: OperationVariables;\n}\n\ninterface InternalState<TData, TVariables extends OperationVariables> {\n  client: ReturnType<typeof useApolloClient>;\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>;\n  observable: ObsQueryWithMeta<TData, TVariables>;\n  resultData: InternalResult<TData>;\n}\n\n/**\n * A hook for executing queries in an Apollo application.\n *\n * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.\n *\n * 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.\n *\n * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.\n *\n * @example\n *\n * ```jsx\n * import { gql } from \"@apollo/client\";\n * import { useQuery } from \"@apollo/client/react\";\n *\n * const GET_GREETING = gql`\n *   query GetGreeting($language: String!) {\n *     greeting(language: $language) {\n *       message\n *     }\n *   }\n * `;\n *\n * function Hello() {\n *   const { loading, error, data } = useQuery(GET_GREETING, {\n *     variables: { language: \"english\" },\n *   });\n *   if (loading) return <p>Loading ...</p>;\n *   return <h1>Hello {data.greeting.message}!</h1>;\n * }\n * ```\n *\n * @param query - A GraphQL query document parsed into an AST by `gql`.\n * @param options - Options to control how the query is executed.\n * @returns Query result object\n */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {\n    returnPartialData: true;\n  }\n): useQuery.Result<\n  TData,\n  TVariables,\n  \"empty\" | \"complete\" | \"streaming\" | \"partial\"\n>;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: SkipToken\n): useQuery.Result<TData, TVariables, \"empty\", Record<string, never>>;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options:\n    | SkipToken\n    | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {\n        returnPartialData: true;\n      })\n): useQuery.Result<\n  TData,\n  TVariables,\n  \"empty\" | \"complete\" | \"streaming\" | \"partial\",\n  Partial<TVariables>\n>;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {\n    returnPartialData: boolean;\n  }\n): useQuery.Result<\n  TData,\n  TVariables,\n  \"empty\" | \"complete\" | \"streaming\" | \"partial\"\n>;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options:\n    | SkipToken\n    | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {\n        returnPartialData: boolean;\n      })\n): useQuery.Result<\n  TData,\n  TVariables,\n  \"empty\" | \"complete\" | \"streaming\" | \"partial\",\n  Partial<TVariables>\n>;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  ...[options]: {} extends TVariables ?\n    [options?: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]\n  : [options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]\n): useQuery.Result<TData, TVariables, \"empty\" | \"complete\" | \"streaming\">;\n\n/** {@inheritDoc @apollo/client/react!useQuery:function(1)} */\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  ...[options]: {} extends TVariables ?\n    [\n      options?:\n        | SkipToken\n        | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>,\n    ]\n  : [options: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]\n): useQuery.Result<\n  TData,\n  TVariables,\n  \"empty\" | \"complete\" | \"streaming\",\n  Partial<TVariables>\n>;\n\nexport function useQuery<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  ...[options]: {} extends TVariables ?\n    [\n      options?:\n        | SkipToken\n        | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>,\n    ]\n  : [options: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]\n): useQuery.Result<TData, TVariables> {\n  \"use no memo\";\n  return wrapHook(\n    \"useQuery\",\n    useQuery_,\n    useApolloClient(typeof options === \"object\" ? options.client : undefined)\n  )(query, options);\n}\n\nfunction useQuery_<TData, TVariables extends OperationVariables>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options:\n    | SkipToken\n    | useQuery.Options<\n        NoInfer<TData>,\n        NoInfer<TVariables>\n      > = {} as useQuery.Options<TData, TVariables>\n): useQuery.Result<TData, TVariables> {\n  const client = useApolloClient(\n    typeof options === \"object\" ? options.client : undefined\n  );\n  const { ssr } = typeof options === \"object\" ? options : {};\n\n  const watchQueryOptions = useOptions(\n    query,\n    options,\n    client.defaultOptions.watchQuery\n  );\n\n  function createState(\n    previous?: InternalState<TData, TVariables>\n  ): InternalState<TData, TVariables> {\n    const observable = client.watchQuery(watchQueryOptions);\n\n    return {\n      client,\n      query,\n      observable,\n      resultData: {\n        current: observable.getCurrentResult(),\n        // Reuse previousData from previous InternalState (if any) to provide\n        // continuity of previousData even if/when the query or client changes.\n        previousData: previous?.resultData.current.data as TData,\n        variables: observable.variables,\n      },\n    };\n  }\n\n  let [state, setState] = React.useState(createState);\n\n  if (client !== state.client || query !== state.query) {\n    // If the client or query have changed, we need to create a new InternalState.\n    // This will trigger a re-render with the new state, but it will also continue\n    // to run the current render function to completion.\n    // Since we sometimes trigger some side-effects in the render function, we\n    // re-assign `state` to the new state to ensure that those side-effects are\n    // triggered with the new state.\n    setState((state = createState(state)));\n  }\n\n  const { observable, resultData } = state;\n\n  useInitialFetchPolicyIfNecessary<TData, TVariables>(\n    watchQueryOptions,\n    observable\n  );\n\n  useResubscribeIfNecessary<TData, TVariables>(\n    resultData, // might get mutated during render\n    observable, // might get mutated during render\n    watchQueryOptions\n  );\n\n  const result = useResult<TData, TVariables>(observable, resultData, ssr);\n\n  const obsQueryFields = React.useMemo(\n    () => ({\n      refetch: observable.refetch.bind(observable),\n      fetchMore: observable.fetchMore.bind(observable),\n      updateQuery: observable.updateQuery.bind(observable),\n      startPolling: observable.startPolling.bind(observable),\n      stopPolling: observable.stopPolling.bind(observable),\n      subscribeToMore: observable.subscribeToMore.bind(observable),\n    }),\n    [observable]\n  );\n\n  const previousData = resultData.previousData;\n  return React.useMemo(() => {\n    const { partial, ...rest } = result;\n\n    return {\n      ...rest,\n      client,\n      observable,\n      variables: observable.variables,\n      previousData,\n      ...obsQueryFields,\n    };\n  }, [result, client, observable, previousData, obsQueryFields]);\n}\n\nconst fromSkipToken = Symbol();\n\nfunction useOptions<TData, TVariables extends OperationVariables>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>,\n  defaultOptions: Partial<ApolloClient.WatchQueryOptions<any, any>> | undefined\n): ApolloClient.WatchQueryOptions<TData, TVariables> {\n  return useDeepMemo<ApolloClient.WatchQueryOptions<TData, TVariables>>(() => {\n    if (options === skipToken) {\n      const opts: ApolloClient.WatchQueryOptions<TData, TVariables> = {\n        ...mergeOptions(defaultOptions as any, {\n          query,\n          fetchPolicy: \"standby\",\n        }),\n        [variablesUnknownSymbol]: true,\n      };\n      (opts as any)[fromSkipToken] = true;\n\n      return opts;\n    }\n\n    const watchQueryOptions: ApolloClient.WatchQueryOptions<TData, TVariables> =\n      mergeOptions(defaultOptions as any, { ...options, query });\n\n    if (options.skip) {\n      watchQueryOptions.initialFetchPolicy =\n        options.initialFetchPolicy || options.fetchPolicy;\n      watchQueryOptions.fetchPolicy = \"standby\";\n    }\n\n    return watchQueryOptions;\n  }, [query, options, defaultOptions]);\n}\n\nfunction useInitialFetchPolicyIfNecessary<\n  TData,\n  TVariables extends OperationVariables,\n>(\n  watchQueryOptions: ApolloClient.WatchQueryOptions<TData, TVariables>,\n  observable: ObsQueryWithMeta<TData, TVariables>\n) {\n  \"use no memo\";\n  if (!watchQueryOptions.fetchPolicy) {\n    watchQueryOptions.fetchPolicy = observable.options.initialFetchPolicy;\n  }\n}\n\nfunction useResult<TData, TVariables extends OperationVariables>(\n  observable: ObsQueryWithMeta<TData, TVariables>,\n  resultData: InternalResult<TData>,\n  ssr: boolean | undefined\n) {\n  \"use no memo\";\n  const fetchPolicy = observable.options.fetchPolicy;\n  return useSyncExternalStore(\n    React.useCallback(\n      (handleStoreChange) => {\n        const subscription = observable\n          // We use the asapScheduler here to prevent issues with trying to\n          // update in the middle of a render. `reobserve` is kicked off in the\n          // middle of a render and because RxJS emits values synchronously,\n          // its possible for this `handleStoreChange` to be called in that same\n          // render. This allows the render to complete before trying to emit a\n          // new value.\n          .pipe(observeOn(asapScheduler))\n          .subscribe((result) => {\n            const previous = resultData.current;\n\n            if (\n              // Avoid rerendering if the result is the same\n              equal(previous, result) &&\n              // Force rerender if the value was emitted because variables\n              // changed, such as when calling `refetch(newVars)` which returns\n              // the same data when `notifyOnNetworkStatusChange` is `false`.\n              equal(resultData.variables, observable.variables)\n            ) {\n              return;\n            }\n\n            resultData.variables = observable.variables;\n\n            if (previous.data && !equal(previous.data, result.data)) {\n              resultData.previousData = previous.data as TData;\n            }\n\n            resultData.current = result;\n            handleStoreChange();\n          });\n\n        // Do the \"unsubscribe\" with a short delay.\n        // This way, an existing subscription can be reused without an additional\n        // request if \"unsubscribe\"  and \"resubscribe\" to the same ObservableQuery\n        // happen in very fast succession.\n        return () => {\n          setTimeout(() => subscription.unsubscribe());\n        };\n      },\n\n      [observable, resultData]\n    ),\n    () => resultData.current,\n    () =>\n      (\n        (fetchPolicy !== \"standby\" && ssr === false) ||\n        fetchPolicy === \"no-cache\"\n      ) ?\n        useQuery.ssrDisabledResult\n      : resultData.current\n  );\n}\n\n// this hook is not compatible with any rules of React, and there's no good way to rewrite it.\n// it should stay a separate hook that will not be optimized by the compiler\nfunction useResubscribeIfNecessary<\n  TData,\n  TVariables extends OperationVariables,\n>(\n  /** this hook will mutate properties on `resultData` */\n  resultData: InternalResult<TData>,\n  /** this hook will mutate properties on `observable` */\n  observable: ObsQueryWithMeta<TData, TVariables>,\n  watchQueryOptions: Readonly<ApolloClient.WatchQueryOptions<TData, TVariables>>\n) {\n  \"use no memo\";\n  if (\n    observable[lastWatchOptions] &&\n    !equal(observable[lastWatchOptions], watchQueryOptions)\n  ) {\n    // If skipToken was used to generate options, we won't know the correct\n    // initialFetchPolicy until the hook is rerendered with real options, so we\n    // set it the next time we get real options\n    if (\n      (observable[lastWatchOptions] as any)[fromSkipToken] &&\n      !watchQueryOptions.initialFetchPolicy\n    ) {\n      (watchQueryOptions.initialFetchPolicy as any) =\n        watchQueryOptions.fetchPolicy;\n    }\n    // Though it might be tempting to postpone this reobserve call to the\n    // useEffect block, we need getCurrentResult to return an appropriate\n    // loading:true result synchronously (later within the same call to\n    // useQuery). Since we already have this.observable here (not true for\n    // the very first call to useQuery), we are not initiating any new\n    // subscriptions, though it does feel less than ideal that reobserve\n    // (potentially) kicks off a network request (for example, when the\n    // variables have changed), which is technically a side-effect.\n    if (shouldReobserve(observable[lastWatchOptions], watchQueryOptions)) {\n      observable.reobserve(watchQueryOptions);\n    } else {\n      observable.applyOptions(watchQueryOptions);\n    }\n\n    // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n    // but save the current data as this.previousData, just like setResult\n    // usually does.\n    const result = observable.getCurrentResult();\n\n    if (!equal(result.data, resultData.current.data)) {\n      resultData.previousData = (resultData.current.data ||\n        (resultData.previousData as TData)) as TData;\n    }\n    resultData.current = result;\n    resultData.variables = observable.variables;\n  }\n  observable[lastWatchOptions] = watchQueryOptions;\n}\n\nfunction shouldReobserve<TData, TVariables extends OperationVariables>(\n  previousOptions: Readonly<ApolloClient.WatchQueryOptions<TData, TVariables>>,\n  options: Readonly<ApolloClient.WatchQueryOptions<TData, TVariables>>\n) {\n  return (\n    previousOptions.query !== options.query ||\n    !equal(previousOptions.variables, options.variables) ||\n    (previousOptions.fetchPolicy !== options.fetchPolicy &&\n      (options.fetchPolicy === \"standby\" ||\n        previousOptions.fetchPolicy === \"standby\"))\n  );\n}\n\nuseQuery.ssrDisabledResult = maybeDeepFreeze({\n  loading: true,\n  data: void 0 as any,\n  dataState: \"empty\",\n  error: void 0,\n  networkStatus: NetworkStatus.loading,\n  partial: true,\n}) satisfies ObservableQuery.Result<any> as ObservableQuery.Result<any>;\n"]}

package/react/hooks/useQueryRefHandlers.d.ts

@@ -0,0 +1,78 @@
+import type { DataState, OperationVariables } from "@apollo/client";
+import type { SubscribeToMoreFunction } from "@apollo/client";
+import type { QueryRef } from "@apollo/client/react";
+import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
+export declare namespace useQueryRefHandlers {
+    interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+        /**
+        * Update the variables of this observable query, and fetch the new results.
+        * This method should be preferred over `setVariables` in most use cases.
+        * 
+        * Returns a `ResultPromise` with an additional `.retain()` method. Calling
+        * `.retain()` keeps the network operation running even if the `ObservableQuery`
+        * no longer requires the result.
+        * 
+        * Note: `refetch()` guarantees that a value will be emitted from the
+        * observable, even if the result is deep equal to the previous value.
+        * 
+        * @param variables - The new set of variables. If there are missing variables,
+        * the previous values of those variables will be used.
+        */
+        refetch: RefetchFunction<TData, TVariables>;
+        /**
+        * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
+        */
+        fetchMore: FetchMoreFunction<TData, TVariables>;
+        /**
+        * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
+        * 
+        * This function returns _another_ function that you can call to terminate the subscription.
+        */
+        subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;
+    }
+    namespace DocumentationTypes {
+        /**
+        * A React hook that returns a `refetch` and `fetchMore` function for a given
+        * `queryRef`.
+        * 
+        * This is useful to get access to handlers for a `queryRef` that was created by
+        * `createQueryPreloader` or when the handlers for a `queryRef` produced in
+        * a different component are inaccessible.
+        * 
+        * @example
+        * 
+        * ```tsx
+        * const MyComponent({ queryRef }) {
+        *   const { refetch, fetchMore } = useQueryRefHandlers(queryRef);
+        * 
+        *   // ...
+        * }
+        * ```
+        * 
+        * @param queryRef - A `QueryRef` returned from `useBackgroundQuery`, `useLoadableQuery`, or `createQueryPreloader`.
+        */
+        function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef<TData, TVariables>): useQueryRefHandlers.Result<TData, TVariables>;
+    }
+}
+/**
+ * A React hook that returns a `refetch` and `fetchMore` function for a given
+ * `queryRef`.
+ *
+ * This is useful to get access to handlers for a `queryRef` that was created by
+ * `createQueryPreloader` or when the handlers for a `queryRef` produced in
+ * a different component are inaccessible.
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent({ queryRef }) {
+ *   const { refetch, fetchMore } = useQueryRefHandlers(queryRef);
+ *
+ *   // ...
+ * }
+ * ```
+ *
+ * @param queryRef - A `QueryRef` returned from `useBackgroundQuery`, `useLoadableQuery`, or `createQueryPreloader`.
+ */
+export declare function useQueryRefHandlers<TData = unknown, TVariables extends OperationVariables = OperationVariables>(queryRef: QueryRef<TData, TVariables, DataState<TData>["dataState"]>): useQueryRefHandlers.Result<TData, TVariables>;
+//# sourceMappingURL=useQueryRefHandlers.d.ts.map

package/react/hooks/useQueryRefHandlers.js

@@ -0,0 +1,68 @@
+import * as React from "react";
+import { assertWrappedQueryRef, getWrappedPromise, unwrapQueryRef, updateWrappedQueryRef, wrapQueryRef, } from "@apollo/client/react/internal";
+import { wrapHook } from "./internal/index.js";
+import { useApolloClient } from "./useApolloClient.js";
+/**
+ * A React hook that returns a `refetch` and `fetchMore` function for a given
+ * `queryRef`.
+ *
+ * This is useful to get access to handlers for a `queryRef` that was created by
+ * `createQueryPreloader` or when the handlers for a `queryRef` produced in
+ * a different component are inaccessible.
+ *
+ * @example
+ *
+ * ```tsx
+ * const MyComponent({ queryRef }) {
+ *   const { refetch, fetchMore } = useQueryRefHandlers(queryRef);
+ *
+ *   // ...
+ * }
+ * ```
+ *
+ * @param queryRef - A `QueryRef` returned from `useBackgroundQuery`, `useLoadableQuery`, or `createQueryPreloader`.
+ */
+export function useQueryRefHandlers(queryRef) {
+    "use no memo";
+    const unwrapped = unwrapQueryRef(queryRef);
+    const clientOrObsQuery = useApolloClient(unwrapped ?
+        // passing an `ObservableQuery` is not supported by the types, but it will
+        // return any truthy value that is passed in as an override so we cast the result
+        unwrapped["observable"]
+        : undefined);
+    return wrapHook("useQueryRefHandlers", useQueryRefHandlers_, clientOrObsQuery)(queryRef);
+}
+function useQueryRefHandlers_(queryRef) {
+    assertWrappedQueryRef(queryRef);
+    const [previousQueryRef, setPreviousQueryRef] = React.useState(queryRef);
+    const [wrappedQueryRef, setWrappedQueryRef] = React.useState(queryRef);
+    const internalQueryRef = unwrapQueryRef(queryRef);
+    // To ensure we can support React transitions, this hook needs to manage the
+    // queryRef state and apply React's state value immediately to the existing
+    // queryRef since this hook doesn't return the queryRef directly
+    if (previousQueryRef !== queryRef) {
+        setPreviousQueryRef(queryRef);
+        setWrappedQueryRef(queryRef);
+    }
+    else {
+        updateWrappedQueryRef(queryRef, getWrappedPromise(wrappedQueryRef));
+    }
+    const refetch = React.useCallback((variables) => {
+        const promise = internalQueryRef.refetch(variables);
+        setWrappedQueryRef(wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    const fetchMore = React.useCallback((options) => {
+        const promise = internalQueryRef.fetchMore(options);
+        setWrappedQueryRef(wrapQueryRef(internalQueryRef));
+        return promise;
+    }, [internalQueryRef]);
+    return {
+        refetch,
+        fetchMore,
+        // TODO: The internalQueryRef doesn't have TVariables' type information so we have to cast it here
+        subscribeToMore: internalQueryRef.observable
+            .subscribeToMore,
+    };
+}
+//# sourceMappingURL=useQueryRefHandlers.js.map

package/react/hooks/useQueryRefHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQueryRefHandlers.js","sourceRoot":"","sources":["../../../src/react/hooks/useQueryRefHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAW/B,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,YAAY,GACb,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AA0BvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,mBAAmB,CAIjC,QAAoE;IAEpE,aAAa,CAAC;IACd,MAAM,SAAS,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC3C,MAAM,gBAAgB,GAAG,eAAe,CACtC,SAAS,CAAC,CAAC;QACT,0EAA0E;QAC1E,iFAAiF;QAChF,SAAS,CAAC,YAAY,CAAS;QAClC,CAAC,CAAC,SAAS,CAC6B,CAAC;IAE3C,OAAO,QAAQ,CACb,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,CACjB,CAAC,QAAQ,CAAC,CAAC;AACd,CAAC;AAED,SAAS,oBAAoB,CAI3B,QAAoE;IAEpE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAChC,MAAM,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACzE,MAAM,CAAC,eAAe,EAAE,kBAAkB,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvE,MAAM,gBAAgB,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IAElD,4EAA4E;IAC5E,2EAA2E;IAC3E,gEAAgE;IAChE,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAClC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QAC9B,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;SAAM,CAAC;QACN,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,MAAM,OAAO,GAAuC,KAAK,CAAC,WAAW,CACnE,CAAC,SAAS,EAAE,EAAE;QACZ,MAAM,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEpD,kBAAkB,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAEnD,OAAO,OAAO,CAAC;IACjB,CAAC,EACD,CAAC,gBAAgB,CAAC,CACnB,CAAC;IAEF,MAAM,SAAS,GAAyC,KAAK,CAAC,WAAW,CACvE,CAAC,OAAO,EAAE,EAAE;QACV,MAAM,OAAO,GAAG,gBAAgB,CAAC,SAAS,CACxC,OAAqD,CACtD,CAAC;QAEF,kBAAkB,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAEnD,OAAO,OAAO,CAAC;IACjB,CAAC,EACD,CAAC,gBAAgB,CAAC,CACnB,CAAC;IAEF,OAAO;QACL,OAAO;QACP,SAAS;QACT,kGAAkG;QAClG,eAAe,EAAE,gBAAgB,CAAC,UAAU;aACzC,eAA6D;KACjE,CAAC;AACJ,CAAC","sourcesContent":["import * as React from \"react\";\n\nimport type { DataState, OperationVariables } from \"@apollo/client\";\nimport type { SubscribeToMoreFunction } from \"@apollo/client\";\nimport type { ApolloClient } from \"@apollo/client\";\nimport type { ObservableQuery } from \"@apollo/client\";\nimport type { QueryRef } from \"@apollo/client/react\";\nimport type {\n  FetchMoreFunction,\n  RefetchFunction,\n} from \"@apollo/client/react/internal\";\nimport {\n  assertWrappedQueryRef,\n  getWrappedPromise,\n  unwrapQueryRef,\n  updateWrappedQueryRef,\n  wrapQueryRef,\n} from \"@apollo/client/react/internal\";\n\nimport { wrapHook } from \"./internal/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\n\nexport declare namespace useQueryRefHandlers {\n  export interface Result<\n    TData = unknown,\n    TVariables extends OperationVariables = OperationVariables,\n  > {\n    /** {@inheritDoc @apollo/client!ObservableQuery#refetch:member(1)} */\n    refetch: RefetchFunction<TData, TVariables>;\n    /** {@inheritDoc @apollo/client!ObservableQuery#fetchMore:member(1)} */\n    fetchMore: FetchMoreFunction<TData, TVariables>;\n    /** {@inheritDoc @apollo/client!ObservableQuery#subscribeToMore:member(1)} */\n    subscribeToMore: SubscribeToMoreFunction<TData, TVariables>;\n  }\n\n  export namespace DocumentationTypes {\n    /** {@inheritDoc @apollo/client/react!useQueryRefHandlers:function(1)} */\n    export function useQueryRefHandlers<\n      TData = unknown,\n      TVariables extends OperationVariables = OperationVariables,\n    >(\n      queryRef: QueryRef<TData, TVariables>\n    ): useQueryRefHandlers.Result<TData, TVariables>;\n  }\n}\n\n/**\n * A React hook that returns a `refetch` and `fetchMore` function for a given\n * `queryRef`.\n *\n * This is useful to get access to handlers for a `queryRef` that was created by\n * `createQueryPreloader` or when the handlers for a `queryRef` produced in\n * a different component are inaccessible.\n *\n * @example\n *\n * ```tsx\n * const MyComponent({ queryRef }) {\n *   const { refetch, fetchMore } = useQueryRefHandlers(queryRef);\n *\n *   // ...\n * }\n * ```\n *\n * @param queryRef - A `QueryRef` returned from `useBackgroundQuery`, `useLoadableQuery`, or `createQueryPreloader`.\n */\nexport function useQueryRefHandlers<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  queryRef: QueryRef<TData, TVariables, DataState<TData>[\"dataState\"]>\n): useQueryRefHandlers.Result<TData, TVariables> {\n  \"use no memo\";\n  const unwrapped = unwrapQueryRef(queryRef);\n  const clientOrObsQuery = useApolloClient(\n    unwrapped ?\n      // passing an `ObservableQuery` is not supported by the types, but it will\n      // return any truthy value that is passed in as an override so we cast the result\n      (unwrapped[\"observable\"] as any)\n    : undefined\n  ) as ApolloClient | ObservableQuery<TData>;\n\n  return wrapHook(\n    \"useQueryRefHandlers\",\n    useQueryRefHandlers_,\n    clientOrObsQuery\n  )(queryRef);\n}\n\nfunction useQueryRefHandlers_<\n  TData = unknown,\n  TVariables extends OperationVariables = OperationVariables,\n>(\n  queryRef: QueryRef<TData, TVariables, DataState<TData>[\"dataState\"]>\n): useQueryRefHandlers.Result<TData, TVariables> {\n  assertWrappedQueryRef(queryRef);\n  const [previousQueryRef, setPreviousQueryRef] = React.useState(queryRef);\n  const [wrappedQueryRef, setWrappedQueryRef] = React.useState(queryRef);\n  const internalQueryRef = unwrapQueryRef(queryRef);\n\n  // To ensure we can support React transitions, this hook needs to manage the\n  // queryRef state and apply React's state value immediately to the existing\n  // queryRef since this hook doesn't return the queryRef directly\n  if (previousQueryRef !== queryRef) {\n    setPreviousQueryRef(queryRef);\n    setWrappedQueryRef(queryRef);\n  } else {\n    updateWrappedQueryRef(queryRef, getWrappedPromise(wrappedQueryRef));\n  }\n\n  const refetch: RefetchFunction<TData, TVariables> = React.useCallback(\n    (variables) => {\n      const promise = internalQueryRef.refetch(variables);\n\n      setWrappedQueryRef(wrapQueryRef(internalQueryRef));\n\n      return promise;\n    },\n    [internalQueryRef]\n  );\n\n  const fetchMore: FetchMoreFunction<TData, TVariables> = React.useCallback(\n    (options) => {\n      const promise = internalQueryRef.fetchMore(\n        options as ObservableQuery.FetchMoreOptions<any, any>\n      );\n\n      setWrappedQueryRef(wrapQueryRef(internalQueryRef));\n\n      return promise;\n    },\n    [internalQueryRef]\n  );\n\n  return {\n    refetch,\n    fetchMore,\n    // TODO: The internalQueryRef doesn't have TVariables' type information so we have to cast it here\n    subscribeToMore: internalQueryRef.observable\n      .subscribeToMore as SubscribeToMoreFunction<TData, TVariables>,\n  };\n}\n"]}

package/react/hooks/useReactiveVar.d.ts

@@ -0,0 +1,22 @@
+import type { ReactiveVar } from "@apollo/client";
+/**
+ * Reads the value of a [reactive variable](https://www.apollographql.com/docs/react/local-state/reactive-variables/) and re-renders the containing component whenever that variable's value changes. This enables a reactive variable to trigger changes _without_ relying on the `useQuery` hook.
+ *
+ * @example
+ *
+ * ```jsx
+ * import { makeVar } from "@apollo/client";
+ * import { useReactiveVar } from "@apollo/client/react";
+ * export const cartItemsVar = makeVar([]);
+ *
+ * export function Cart() {
+ *   const cartItems = useReactiveVar(cartItemsVar);
+ *   // ...
+ * }
+ * ```
+ *
+ * @param rv - A reactive variable.
+ * @returns The current value of the reactive variable.
+ */
+export declare function useReactiveVar<T>(rv: ReactiveVar<T>): T;
+//# sourceMappingURL=useReactiveVar.d.ts.map

package/react/hooks/useReactiveVar.js

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { useSyncExternalStore } from "./useSyncExternalStore.js";
+/**
+ * Reads the value of a [reactive variable](https://www.apollographql.com/docs/react/local-state/reactive-variables/) and re-renders the containing component whenever that variable's value changes. This enables a reactive variable to trigger changes _without_ relying on the `useQuery` hook.
+ *
+ * @example
+ *
+ * ```jsx
+ * import { makeVar } from "@apollo/client";
+ * import { useReactiveVar } from "@apollo/client/react";
+ * export const cartItemsVar = makeVar([]);
+ *
+ * export function Cart() {
+ *   const cartItems = useReactiveVar(cartItemsVar);
+ *   // ...
+ * }
+ * ```
+ *
+ * @param rv - A reactive variable.
+ * @returns The current value of the reactive variable.
+ */
+export function useReactiveVar(rv) {
+    return useSyncExternalStore(React.useCallback((update) => {
+        // By reusing the same onNext function in the nested call to
+        // rv.onNextChange(onNext), we can keep using the initial clean-up function
+        // returned by rv.onNextChange(function onNext(v){...}), without having to
+        // register the new clean-up function (returned by the nested
+        // rv.onNextChange(onNext)) with yet another callback.
+        return rv.onNextChange(function onNext() {
+            update();
+            rv.onNextChange(onNext);
+        });
+    }, [rv]), rv, rv);
+}
+//# sourceMappingURL=useReactiveVar.js.map

package/react/hooks/useReactiveVar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReactiveVar.js","sourceRoot":"","sources":["../../../src/react/hooks/useReactiveVar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,cAAc,CAAI,EAAkB;IAClD,OAAO,oBAAoB,CACzB,KAAK,CAAC,WAAW,CACf,CAAC,MAAM,EAAE,EAAE;QACT,4DAA4D;QAC5D,2EAA2E;QAC3E,0EAA0E;QAC1E,6DAA6D;QAC7D,sDAAsD;QACtD,OAAO,EAAE,CAAC,YAAY,CAAC,SAAS,MAAM;YACpC,MAAM,EAAE,CAAC;YACT,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC1B,CAAC,CAAC,CAAC;IACL,CAAC,EACD,CAAC,EAAE,CAAC,CACL,EACD,EAAE,EACF,EAAE,CACH,CAAC;AACJ,CAAC","sourcesContent":["import * as React from \"react\";\n\nimport type { ReactiveVar } from \"@apollo/client\";\n\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\n\n/**\n * Reads the value of a [reactive variable](https://www.apollographql.com/docs/react/local-state/reactive-variables/) and re-renders the containing component whenever that variable's value changes. This enables a reactive variable to trigger changes _without_ relying on the `useQuery` hook.\n *\n * @example\n *\n * ```jsx\n * import { makeVar } from \"@apollo/client\";\n * import { useReactiveVar } from \"@apollo/client/react\";\n * export const cartItemsVar = makeVar([]);\n *\n * export function Cart() {\n *   const cartItems = useReactiveVar(cartItemsVar);\n *   // ...\n * }\n * ```\n *\n * @param rv - A reactive variable.\n * @returns The current value of the reactive variable.\n */\nexport function useReactiveVar<T>(rv: ReactiveVar<T>): T {\n  return useSyncExternalStore(\n    React.useCallback(\n      (update) => {\n        // By reusing the same onNext function in the nested call to\n        // rv.onNextChange(onNext), we can keep using the initial clean-up function\n        // returned by rv.onNextChange(function onNext(v){...}), without having to\n        // register the new clean-up function (returned by the nested\n        // rv.onNextChange(onNext)) with yet another callback.\n        return rv.onNextChange(function onNext() {\n          update();\n          rv.onNextChange(onNext);\n        });\n      },\n      [rv]\n    ),\n    rv,\n    rv\n  );\n}\n"]}

package/react/hooks/useReadQuery.d.ts

@@ -0,0 +1,100 @@
+import type { DataState, ErrorLike, GetDataState, NetworkStatus } from "@apollo/client";
+import type { MaybeMasked } from "@apollo/client/masking";
+import type { QueryRef } from "@apollo/client/react";
+import type { DocumentationTypes as UtilityDocumentationTypes } from "@apollo/client/utilities/internal";
+export declare namespace useReadQuery {
+    namespace Base {
+        interface Result<TData = unknown> {
+            /**
+            * A single ErrorLike object describing the error that occurred during the latest
+            * query execution.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            * 
+            * @docGroup 1. Operation data
+            *      
+            *
+            * This property can be ignored when using the default `errorPolicy` or an
+            * `errorPolicy` of `none`. The hook will throw the error instead of setting
+            * this property.
+            */
+            error: ErrorLike | undefined;
+            /**
+            * A number indicating the current network state of the query's associated request. [See possible values.](https://github.com/apollographql/apollo-client/blob/d96f4578f89b933c281bb775a39503f6cdb59ee8/src/core/networkStatus.ts#L4)
+            * 
+            * Used in conjunction with the [`notifyOnNetworkStatusChange`](#notifyonnetworkstatuschange) option.
+            * 
+            * @docGroup 2. Network info
+            */
+            networkStatus: NetworkStatus;
+        }
+    }
+    type Result<TData = unknown, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData> & GetDataState<MaybeMasked<TData>, TStates>;
+    namespace DocumentationTypes {
+        namespace useReadQuery {
+            interface Result<TData = unknown> extends Base.Result<TData>, UtilityDocumentationTypes.DataState<TData> {
+            }
+        }
+        /**
+        * For a detailed explanation of `useReadQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense#avoiding-request-waterfalls).
+        * 
+        * @param queryRef - The `QueryRef` that was generated via `useBackgroundQuery`.
+        * @returns An object containing the query result data, error, and network status.
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { Suspense } from "react";
+        * import { useBackgroundQuery, useReadQuery } from "@apollo/client";
+        * 
+        * function Parent() {
+        *   const [queryRef] = useBackgroundQuery(query);
+        * 
+        *   return (
+        *     <Suspense fallback={<div>Loading...</div>}>
+        *       <Child queryRef={queryRef} />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function Child({ queryRef }) {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   return <div>{data.name}</div>;
+        * }
+        * ```
+        */
+        function useReadQuery<TData>(queryRef: QueryRef<TData>): useReadQuery.Result<TData>;
+    }
+}
+/**
+ * For a detailed explanation of `useReadQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense#avoiding-request-waterfalls).
+ *
+ * @param queryRef - The `QueryRef` that was generated via `useBackgroundQuery`.
+ * @returns An object containing the query result data, error, and network status.
+ *
+ * @example
+ *
+ * ```jsx
+ * import { Suspense } from "react";
+ * import { useBackgroundQuery, useReadQuery } from "@apollo/client";
+ *
+ * function Parent() {
+ *   const [queryRef] = useBackgroundQuery(query);
+ *
+ *   return (
+ *     <Suspense fallback={<div>Loading...</div>}>
+ *       <Child queryRef={queryRef} />
+ *     </Suspense>
+ *   );
+ * }
+ *
+ * function Child({ queryRef }) {
+ *   const { data } = useReadQuery(queryRef);
+ *
+ *   return <div>{data.name}</div>;
+ * }
+ * ```
+ */
+export declare function useReadQuery<TData, TStates extends DataState<TData>["dataState"]>(queryRef: QueryRef<TData, any, TStates>): useReadQuery.Result<TData, TStates>;
+//# sourceMappingURL=useReadQuery.d.ts.map