@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.1

package/core/QueryManager.js

@@ -1,70 +1,57 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { invariant, newInvariantError } from "../utilities/globals/index.js";
+import { equal } from "@wry/equality";
+import { execute } from "../link/core/index.js";
+import { addNonReactiveToNamedFragments, hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, isFullyUnmaskedOperation, removeDirectivesFromDocument, } from "../utilities/index.js";
+import { canonicalStringify } from "../cache/index.js";
+import { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, getGraphQLErrorsFromResult, Observable, asyncMap, isNonEmptyArray, Concast, makeUniqueId, isDocumentNode, isNonNullObject, DocumentTransform, } from "../utilities/index.js";
+import { mergeIncrementalData } from "../utilities/common/incrementalResult.js";
+import { ApolloError, isApolloError, graphQLResultHasProtocolErrors, } from "../errors/index.js";
+import { ObservableQuery, logMissingFieldErrors } from "./ObservableQuery.js";
+import { NetworkStatus, isNetworkRequestInFlight } from "./networkStatus.js";
+import { QueryInfo, shouldWriteResult, } from "./QueryInfo.js";
+import { PROTOCOL_ERRORS_SYMBOL } from "../errors/index.js";
+import { print } from "../utilities/index.js";
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var IGNORE = Object.create(null);
 import { Trie } from "@wry/trie";
-import { BREAK, Kind, OperationTypeNode, visit } from "graphql";
-import { Observable, throwError } from "rxjs";
-import { catchError, concat, EMPTY, filter, finalize, from, lastValueFrom, map, materialize, mergeMap, of, share, shareReplay, Subject, tap, } from "rxjs";
-import { canonicalStringify } from "@apollo/client/cache";
-import { CombinedGraphQLErrors, graphQLResultHasProtocolErrors, registerLinkError, toErrorLike, } from "@apollo/client/errors";
-import { PROTOCOL_ERRORS_SYMBOL } from "@apollo/client/errors";
-import { execute } from "@apollo/client/link";
-import { maskFragment, maskOperation } from "@apollo/client/masking";
-import { cacheSizes, DocumentTransform, print } from "@apollo/client/utilities";
-import { __DEV__ } from "@apollo/client/utilities/environment";
-import { AutoCleanedWeakCache, checkDocument, filterMap, getDefaultValues, getOperationDefinition, getOperationName, graphQLResultHasError, hasDirectives, hasForcedResolvers, isDocumentNode, isNonNullObject, makeUniqueId, removeDirectivesFromDocument, toQueryResult, } from "@apollo/client/utilities/internal";
-import { invariant, newInvariantError, } from "@apollo/client/utilities/invariant";
-import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
-import { logMissingFieldErrors, ObservableQuery } from "./ObservableQuery.js";
-import { QueryInfo } from "./QueryInfo.js";
-export class QueryManager {
-    defaultOptions;
-    client;
-    /**
-     * The options that were passed to the ApolloClient constructor.
-     */
-    clientOptions;
-    assumeImmutableResults;
-    documentTransform;
-    ssrMode;
-    defaultContext;
-    dataMasking;
-    incrementalHandler;
-    localState;
-    queryDeduplication;
-    /**
-     * Whether to prioritize cache values over network results when
-     * `fetchObservableWithInfo` is called.
-     * This will essentially turn a `"network-only"` or `"cache-and-network"`
-     * fetchPolicy into a `"cache-first"` fetchPolicy, but without influencing
-     * the `fetchPolicy` of the `ObservableQuery`.
-     *
-     * This can e.g. be used to prioritize the cache during the first render after
-     * SSR.
-     */
-    prioritizeCacheValues = false;
-    onBroadcast;
-    mutationStore;
-    /**
-     * All ObservableQueries that currently have at least one subscriber.
-     */
-    obsQueries = new Set();
-    // Maps from queryInfo.id strings to Promise rejection functions for
-    // currently active queries and fetches.
-    // Use protected instead of private field so
-    // @apollo/experimental-nextjs-app-support can access type info.
-    fetchCancelFns = new Map();
-    constructor(options) {
-        const defaultDocumentTransform = new DocumentTransform((document) => this.cache.transformDocument(document), 
+import { AutoCleanedWeakCache, cacheSizes } from "../utilities/index.js";
+import { maskFragment, maskOperation } from "../masking/index.js";
+import { muteDeprecations } from "../utilities/deprecation/index.js";
+var QueryManager = /** @class */ (function () {
+    function QueryManager(options) {
+        var _this = this;
+        this.clientAwareness = {};
+        // All the queries that the QueryManager is currently managing (not
+        // including mutations and subscriptions).
+        this.queries = new Map();
+        // Maps from queryId strings to Promise rejection functions for
+        // currently active queries and fetches.
+        // Use protected instead of private field so
+        // @apollo/experimental-nextjs-app-support can access type info.
+        this.fetchCancelFns = new Map();
+        this.transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
+            2000 /* defaultCacheSizes["queryManager.getDocumentInfo"] */);
+        this.queryIdCounter = 1;
+        this.requestIdCounter = 1;
+        this.mutationIdCounter = 1;
+        // Use protected instead of private field so
+        // @apollo/experimental-nextjs-app-support can access type info.
+        this.inFlightLinkObservables = new Trie(false);
+        this.noCacheWarningsByQueryId = new Set();
+        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); }, 
         // Allow the apollo cache to manage its own transform caches
         { cache: false });
-        this.client = options.client;
+        this.cache = options.cache;
+        this.link = options.link;
         this.defaultOptions = options.defaultOptions;
         this.queryDeduplication = options.queryDeduplication;
-        this.clientOptions = options.clientOptions;
+        this.clientAwareness = options.clientAwareness;
+        this.localState = options.localState;
         this.ssrMode = options.ssrMode;
         this.assumeImmutableResults = options.assumeImmutableResults;
         this.dataMasking = options.dataMasking;
-        this.localState = options.localState;
-        this.incrementalHandler = options.incrementalHandler;
-        const documentTransform = options.documentTransform;
+        var documentTransform = options.documentTransform;
         this.documentTransform =
             documentTransform ?
                 defaultDocumentTransform
@@ -75,298 +62,492 @@ export class QueryManager {
                     // selections and fragments from the fragment registry.
                     .concat(defaultDocumentTransform)
                 : defaultDocumentTransform;
-        this.defaultContext = options.defaultContext || {};
+        this.defaultContext = options.defaultContext || Object.create(null);
         if ((this.onBroadcast = options.onBroadcast)) {
-            this.mutationStore = {};
+            this.mutationStore = Object.create(null);
         }
     }
-    get link() {
-        return this.client.link;
-    }
-    get cache() {
-        return this.client.cache;
-    }
     /**
      * Call this method to terminate any active query processes, making it safe
      * to dispose of this QueryManager instance.
      */
-    stop() {
-        this.obsQueries.forEach((oq) => oq.stop());
-        this.cancelPendingFetches(newInvariantError(85));
-    }
-    cancelPendingFetches(error) {
-        this.fetchCancelFns.forEach((cancel) => cancel(error));
+    QueryManager.prototype.stop = function () {
+        var _this = this;
+        this.queries.forEach(function (_info, queryId) {
+            _this.stopQueryNoBroadcast(queryId);
+        });
+        this.cancelPendingFetches(newInvariantError(35));
+    };
+    QueryManager.prototype.cancelPendingFetches = function (error) {
+        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
         this.fetchCancelFns.clear();
-    }
-    async mutate({ mutation, variables, optimisticResponse, updateQueries, refetchQueries = [], awaitRefetchQueries = false, update: updateWithProxyFn, onQueryUpdated, fetchPolicy, errorPolicy, keepRootFields, context, }) {
-        const queryInfo = new QueryInfo(this);
-        mutation = this.cache.transformForLink(this.transform(mutation));
-        const { hasClientExports } = this.getDocumentInfo(mutation);
-        variables = this.getVariables(mutation, variables);
-        if (hasClientExports) {
-            if (__DEV__) {
-                invariant(this.localState, 86, getOperationName(mutation, "(anonymous)"));
-            }
-            variables = await this.localState.getExportedVariables({
-                client: this.client,
-                document: mutation,
-                variables,
-                context,
-            });
-        }
-        const mutationStoreValue = this.mutationStore &&
-            (this.mutationStore[queryInfo.id] = {
-                mutation,
-                variables,
-                loading: true,
-                error: null,
-            });
-        const isOptimistic = optimisticResponse &&
-            queryInfo.markMutationOptimistic(optimisticResponse, {
-                document: mutation,
-                variables,
-                cacheWriteBehavior: fetchPolicy === "no-cache" ?
-                    0 /* CacheWriteBehavior.FORBID */
-                    : 2 /* CacheWriteBehavior.MERGE */,
-                errorPolicy,
-                context,
-                updateQueries,
-                update: updateWithProxyFn,
-                keepRootFields,
+    };
+    QueryManager.prototype.mutate = function (_a) {
+        return __awaiter(this, arguments, void 0, function (_b) {
+            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;
+            var _c, _d;
+            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || "network-only" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || "none" : _h, keepRootFields = _b.keepRootFields, context = _b.context;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        invariant(mutation, 36);
+                        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 37);
+                        mutationId = this.generateMutationId();
+                        mutation = this.cache.transformForLink(this.transform(mutation));
+                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;
+                        variables = this.getVariables(mutation, variables);
+                        if (!hasClientExports) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.localState.addExportedVariables(mutation, variables, context)];
+                    case 1:
+                        variables = (_j.sent());
+                        _j.label = 2;
+                    case 2:
+                        mutationStoreValue = this.mutationStore &&
+                            (this.mutationStore[mutationId] = {
+                                mutation: mutation,
+                                variables: variables,
+                                loading: true,
+                                error: null,
+                            });
+                        isOptimistic = optimisticResponse &&
+                            this.markMutationOptimistic(optimisticResponse, {
+                                mutationId: mutationId,
+                                document: mutation,
+                                variables: variables,
+                                fetchPolicy: fetchPolicy,
+                                errorPolicy: errorPolicy,
+                                context: context,
+                                updateQueries: updateQueries,
+                                update: updateWithProxyFn,
+                                keepRootFields: keepRootFields,
+                            });
+                        this.broadcastQueries();
+                        self = this;
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {
+                                    if (graphQLResultHasError(result) && errorPolicy === "none") {
+                                        throw new ApolloError({
+                                            graphQLErrors: getGraphQLErrorsFromResult(result),
+                                        });
+                                    }
+                                    if (mutationStoreValue) {
+                                        mutationStoreValue.loading = false;
+                                        mutationStoreValue.error = null;
+                                    }
+                                    var storeResult = __assign({}, result);
+                                    if (typeof refetchQueries === "function") {
+                                        refetchQueries = refetchQueries(storeResult);
+                                    }
+                                    if (errorPolicy === "ignore" && graphQLResultHasError(storeResult)) {
+                                        delete storeResult.errors;
+                                    }
+                                    return self.markMutationResult({
+                                        mutationId: mutationId,
+                                        result: storeResult,
+                                        document: mutation,
+                                        variables: variables,
+                                        fetchPolicy: fetchPolicy,
+                                        errorPolicy: errorPolicy,
+                                        context: context,
+                                        update: updateWithProxyFn,
+                                        updateQueries: updateQueries,
+                                        awaitRefetchQueries: awaitRefetchQueries,
+                                        refetchQueries: refetchQueries,
+                                        removeOptimistic: isOptimistic ? mutationId : void 0,
+                                        onQueryUpdated: onQueryUpdated,
+                                        keepRootFields: keepRootFields,
+                                    });
+                                }).subscribe({
+                                    next: function (storeResult) {
+                                        self.broadcastQueries();
+                                        // Since mutations might receive multiple payloads from the
+                                        // ApolloLink chain (e.g. when used with @defer),
+                                        // we resolve with a SingleExecutionResult or after the final
+                                        // ExecutionPatchResult has arrived and we have assembled the
+                                        // multipart response into a single result.
+                                        if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
+                                            resolve(__assign(__assign({}, storeResult), { data: self.maskOperation({
+                                                    document: mutation,
+                                                    data: storeResult.data,
+                                                    fetchPolicy: fetchPolicy,
+                                                    id: mutationId,
+                                                }) }));
+                                        }
+                                    },
+                                    error: function (err) {
+                                        if (mutationStoreValue) {
+                                            mutationStoreValue.loading = false;
+                                            mutationStoreValue.error = err;
+                                        }
+                                        if (isOptimistic) {
+                                            self.cache.removeOptimistic(mutationId);
+                                        }
+                                        self.broadcastQueries();
+                                        reject(err instanceof ApolloError ? err : (new ApolloError({
+                                            networkError: err,
+                                        })));
+                                    },
+                                });
+                            })];
+                }
             });
-        this.broadcastQueries();
-        return new Promise((resolve, reject) => {
-            const cause = {};
-            return this.getObservableFromLink(mutation, {
-                ...context,
-                optimisticResponse: isOptimistic ? optimisticResponse : void 0,
-            }, variables, {}, false)
-                .observable.pipe(validateDidEmitValue(), mergeMap((result) => {
-                const storeResult = { ...result };
-                return from(queryInfo.markMutationResult(storeResult, {
-                    document: mutation,
-                    variables,
-                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
-                        0 /* CacheWriteBehavior.FORBID */
-                        : 2 /* CacheWriteBehavior.MERGE */,
-                    errorPolicy,
-                    context,
-                    update: updateWithProxyFn,
-                    updateQueries,
-                    awaitRefetchQueries,
-                    refetchQueries,
-                    removeOptimistic: isOptimistic ? queryInfo.id : void 0,
-                    onQueryUpdated,
-                    keepRootFields,
-                }));
-            }))
-                .pipe(map((storeResult) => {
-                const hasErrors = graphQLResultHasError(storeResult);
-                if (hasErrors && errorPolicy === "none") {
-                    throw new CombinedGraphQLErrors(storeResult);
+        });
+    };
+    QueryManager.prototype.markMutationResult = function (mutation, cache) {
+        var _this = this;
+        if (cache === void 0) { cache = this.cache; }
+        var result = mutation.result;
+        var cacheWrites = [];
+        var skipCache = mutation.fetchPolicy === "no-cache";
+        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
+            if (!isExecutionPatchIncrementalResult(result)) {
+                cacheWrites.push({
+                    result: result.data,
+                    dataId: "ROOT_MUTATION",
+                    query: mutation.document,
+                    variables: mutation.variables,
+                });
+            }
+            if (isExecutionPatchIncrementalResult(result) &&
+                isNonEmptyArray(result.incremental)) {
+                var diff = cache.diff({
+                    id: "ROOT_MUTATION",
+                    // The cache complains if passed a mutation where it expects a
+                    // query, so we transform mutations and subscriptions to queries
+                    // (only once, thanks to this.transformCache).
+                    query: this.getDocumentInfo(mutation.document).asQuery,
+                    variables: mutation.variables,
+                    optimistic: false,
+                    returnPartialData: true,
+                });
+                var mergedData = void 0;
+                if (diff.result) {
+                    mergedData = mergeIncrementalData(diff.result, result);
                 }
-                if (mutationStoreValue) {
-                    mutationStoreValue.loading = false;
-                    mutationStoreValue.error = null;
+                if (typeof mergedData !== "undefined") {
+                    // cast the ExecutionPatchResult to FetchResult here since
+                    // ExecutionPatchResult never has `data` when returned from the server
+                    result.data = mergedData;
+                    cacheWrites.push({
+                        result: mergedData,
+                        dataId: "ROOT_MUTATION",
+                        query: mutation.document,
+                        variables: mutation.variables,
+                    });
                 }
-                return storeResult;
-            }))
-                .subscribe({
-                next: (storeResult) => {
-                    this.broadcastQueries();
-                    // Since mutations might receive multiple payloads from the
-                    // ApolloLink chain (e.g. when used with @defer),
-                    // we resolve with a SingleExecutionResult or after the final
-                    // ExecutionPatchResult has arrived and we have assembled the
-                    // multipart response into a single result.
-                    if (!queryInfo.hasNext) {
-                        const result = {
-                            data: this.maskOperation({
-                                document: mutation,
-                                data: storeResult.data,
-                                fetchPolicy,
-                                cause,
-                            }),
-                        };
-                        if (graphQLResultHasError(storeResult)) {
-                            result.error = new CombinedGraphQLErrors(storeResult);
-                        }
-                        if (Object.keys(storeResult.extensions || {}).length) {
-                            result.extensions = storeResult.extensions;
-                        }
-                        resolve(result);
+            }
+            var updateQueries_1 = mutation.updateQueries;
+            if (updateQueries_1) {
+                this.queries.forEach(function (_a, queryId) {
+                    var observableQuery = _a.observableQuery;
+                    var queryName = observableQuery && observableQuery.queryName;
+                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {
+                        return;
                     }
-                },
-                error: (error) => {
-                    if (mutationStoreValue) {
-                        mutationStoreValue.loading = false;
-                        mutationStoreValue.error = error;
+                    var updater = updateQueries_1[queryName];
+                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;
+                    // Read the current query result from the store.
+                    var _c = cache.diff({
+                        query: document,
+                        variables: variables,
+                        returnPartialData: true,
+                        optimistic: false,
+                    }), currentQueryResult = _c.result, complete = _c.complete;
+                    if (complete && currentQueryResult) {
+                        // Run our reducer using the current query result and the mutation result.
+                        var nextQueryResult = updater(currentQueryResult, {
+                            mutationResult: result,
+                            queryName: (document && getOperationName(document)) || void 0,
+                            queryVariables: variables,
+                        });
+                        // Write the modified result back into the store if we got a new result.
+                        if (nextQueryResult) {
+                            cacheWrites.push({
+                                result: nextQueryResult,
+                                dataId: "ROOT_QUERY",
+                                query: document,
+                                variables: variables,
+                            });
+                        }
                     }
-                    if (isOptimistic) {
-                        this.cache.removeOptimistic(queryInfo.id);
+                });
+            }
+        }
+        if (cacheWrites.length > 0 ||
+            (mutation.refetchQueries || "").length > 0 ||
+            mutation.update ||
+            mutation.onQueryUpdated ||
+            mutation.removeOptimistic) {
+            var results_1 = [];
+            this.refetchQueries({
+                updateCache: function (cache) {
+                    if (!skipCache) {
+                        cacheWrites.forEach(function (write) { return cache.write(write); });
                     }
-                    this.broadcastQueries();
-                    if (errorPolicy === "ignore") {
-                        return resolve({ data: undefined });
+                    // If the mutation has some writes associated with it then we need to
+                    // apply those writes to the store by running this reducer again with
+                    // a write action.
+                    var update = mutation.update;
+                    // Determine whether result is a SingleExecutionResult,
+                    // or the final ExecutionPatchResult.
+                    var isFinalResult = !isExecutionPatchResult(result) ||
+                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
+                    if (update) {
+                        if (!skipCache) {
+                            // Re-read the ROOT_MUTATION data we just wrote into the cache
+                            // (the first cache.write call in the cacheWrites.forEach loop
+                            // above), so field read functions have a chance to run for
+                            // fields within mutation result objects.
+                            var diff = cache.diff({
+                                id: "ROOT_MUTATION",
+                                // The cache complains if passed a mutation where it expects a
+                                // query, so we transform mutations and subscriptions to queries
+                                // (only once, thanks to this.transformCache).
+                                query: _this.getDocumentInfo(mutation.document).asQuery,
+                                variables: mutation.variables,
+                                optimistic: false,
+                                returnPartialData: true,
+                            });
+                            if (diff.complete) {
+                                result = __assign(__assign({}, result), { data: diff.result });
+                                if ("incremental" in result) {
+                                    delete result.incremental;
+                                }
+                                if ("hasNext" in result) {
+                                    delete result.hasNext;
+                                }
+                            }
+                        }
+                        // If we've received the whole response,
+                        // either a SingleExecutionResult or the final ExecutionPatchResult,
+                        // call the update function.
+                        if (isFinalResult) {
+                            update(cache, result, {
+                                context: mutation.context,
+                                variables: mutation.variables,
+                            });
+                        }
                     }
-                    if (errorPolicy === "all") {
-                        return resolve({ data: undefined, error });
+                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
+                    // shallow to allow rolling back optimistic evictions.
+                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
+                        cache.modify({
+                            id: "ROOT_MUTATION",
+                            fields: function (value, _a) {
+                                var fieldName = _a.fieldName, DELETE = _a.DELETE;
+                                return fieldName === "__typename" ? value : DELETE;
+                            },
+                        });
                     }
-                    reject(error);
                 },
-            });
-        });
-    }
-    fetchQuery(options, networkStatus) {
-        checkDocument(options.query, OperationTypeNode.QUERY);
-        // do the rest asynchronously to keep the same rejection timing as
-        // checks further in `.mutate`
-        return (async () => lastValueFrom(this.fetchObservableWithInfo(options, {
-            networkStatus,
-        }).observable.pipe(filterMap((value) => {
-            switch (value.kind) {
-                case "E":
-                    throw value.error;
-                case "N": {
-                    if (value.source !== "newNetworkStatus")
-                        return toQueryResult(value.value);
-                }
+                include: mutation.refetchQueries,
+                // Write the final mutation.result to the root layer of the cache.
+                optimistic: false,
+                // Remove the corresponding optimistic layer at the same time as we
+                // write the final non-optimistic result.
+                removeOptimistic: mutation.removeOptimistic,
+                // Let the caller of client.mutate optionally determine the refetching
+                // behavior for watched queries after the mutation.update function runs.
+                // If no onQueryUpdated function was provided for this mutation, pass
+                // null instead of undefined to disable the default refetching behavior.
+                onQueryUpdated: mutation.onQueryUpdated || null,
+            }).forEach(function (result) { return results_1.push(result); });
+            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
+                // Returning a promise here makes the mutation await that promise, so we
+                // include results in that promise's work if awaitRefetchQueries or an
+                // onQueryUpdated function was specified.
+                return Promise.all(results_1).then(function () { return result; });
             }
-        })), {
-            // This default is needed when a `standby` fetch policy is used to avoid
-            // an EmptyError from rejecting this promise.
-            defaultValue: { data: undefined },
-        }))();
-    }
-    transform(document) {
+        }
+        return Promise.resolve(result);
+    };
+    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {
+        var _this = this;
+        var data = typeof optimisticResponse === "function" ?
+            optimisticResponse(mutation.variables, { IGNORE: IGNORE })
+            : optimisticResponse;
+        if (data === IGNORE) {
+            return false;
+        }
+        this.cache.recordOptimisticTransaction(function (cache) {
+            try {
+                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);
+            }
+            catch (error) {
+                globalThis.__DEV__ !== false && invariant.error(error);
+            }
+        }, mutation.mutationId);
+        return true;
+    };
+    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {
+        return this.fetchConcastWithInfo(this.getOrCreateQuery(queryId), options, networkStatus).concast.promise;
+    };
+    QueryManager.prototype.getQueryStore = function () {
+        var store = Object.create(null);
+        this.queries.forEach(function (info, queryId) {
+            store[queryId] = {
+                variables: info.variables,
+                networkStatus: info.networkStatus,
+                networkError: info.networkError,
+                graphQLErrors: info.graphQLErrors,
+            };
+        });
+        return store;
+    };
+    QueryManager.prototype.resetErrors = function (queryId) {
+        var queryInfo = this.queries.get(queryId);
+        if (queryInfo) {
+            queryInfo.networkError = undefined;
+            queryInfo.graphQLErrors = [];
+        }
+    };
+    QueryManager.prototype.transform = function (document) {
         return this.documentTransform.transformDocument(document);
-    }
-    transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
-        2000 /* defaultCacheSizes["queryManager.getDocumentInfo"] */);
-    getDocumentInfo(document) {
-        const { transformCache } = this;
+    };
+    QueryManager.prototype.getDocumentInfo = function (document) {
+        var transformCache = this.transformCache;
         if (!transformCache.has(document)) {
-            const operationDefinition = getOperationDefinition(document);
-            const cacheEntry = {
+            var cacheEntry = {
                 // TODO These three calls (hasClientExports, shouldForceResolvers, and
                 // usesNonreactiveDirective) are performing independent full traversals
                 // of the transformed document. We should consider merging these
                 // traversals into a single pass in the future, though the work is
                 // cached after the first time.
-                hasClientExports: hasDirectives(["client", "export"], document, true),
-                hasForcedResolvers: hasForcedResolvers(document),
+                hasClientExports: hasClientExports(document),
+                hasForcedResolvers: this.localState.shouldForceResolvers(document),
                 hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
-                hasIncrementalDirective: hasDirectives(["defer"], document),
                 nonReactiveQuery: addNonReactiveToNamedFragments(document),
-                clientQuery: hasDirectives(["client"], document) ? document : null,
+                clientQuery: this.localState.clientQuery(document),
                 serverQuery: removeDirectivesFromDocument([
                     { name: "client", remove: true },
                     { name: "connection" },
                     { name: "nonreactive" },
                     { name: "unmask" },
                 ], document),
-                operationType: operationDefinition?.operation,
-                defaultVars: getDefaultValues(operationDefinition),
+                defaultVars: getDefaultValues(getOperationDefinition(document)),
                 // Transform any mutation or subscription operations to query operations
                 // so we can read/write them from/to the cache.
-                asQuery: {
-                    ...document,
-                    definitions: document.definitions.map((def) => {
+                asQuery: __assign(__assign({}, document), { definitions: document.definitions.map(function (def) {
                         if (def.kind === "OperationDefinition" &&
                             def.operation !== "query") {
-                            return { ...def, operation: "query" };
+                            return __assign(__assign({}, def), { operation: "query" });
                         }
                         return def;
-                    }),
-                },
+                    }) }),
             };
             transformCache.set(document, cacheEntry);
         }
-        const entry = transformCache.get(document);
-        if (entry.violation) {
-            throw entry.violation;
-        }
-        return entry;
-    }
-    getVariables(document, variables) {
-        const defaultVars = this.getDocumentInfo(document).defaultVars;
-        const varsWithDefaults = Object.entries(variables ?? {}).map(([key, value]) => [key, value === undefined ? defaultVars[key] : value]);
-        return {
-            ...defaultVars,
-            ...Object.fromEntries(varsWithDefaults),
-        };
-    }
-    watchQuery(options) {
-        checkDocument(options.query, OperationTypeNode.QUERY);
-        const query = this.transform(options.query);
+        return transformCache.get(document);
+    };
+    QueryManager.prototype.getVariables = function (document, variables) {
+        return __assign(__assign({}, this.getDocumentInfo(document).defaultVars), variables);
+    };
+    QueryManager.prototype.watchQuery = function (options) {
+        var query = this.transform(options.query);
         // assign variable default values if supplied
         // NOTE: We don't modify options.query here with the transformed query to
         // ensure observable.options.query is set to the raw untransformed query.
-        options = {
-            ...options,
-            variables: this.getVariables(query, options.variables),
-        };
+        options = __assign(__assign({}, options), { variables: this.getVariables(query, options.variables) });
         if (typeof options.notifyOnNetworkStatusChange === "undefined") {
-            options.notifyOnNetworkStatusChange = true;
+            options.notifyOnNetworkStatusChange = false;
         }
-        const observable = new ObservableQuery({
+        var queryInfo = new QueryInfo(this);
+        var observable = new ObservableQuery({
             queryManager: this,
-            options,
-            transformedQuery: query,
+            queryInfo: queryInfo,
+            options: options,
+        });
+        observable["lastQuery"] = query;
+        if (!ObservableQuery["inactiveOnCreation"].getValue()) {
+            this.queries.set(observable.queryId, queryInfo);
+        }
+        // We give queryInfo the transformed query to ensure the first cache diff
+        // uses the transformed query instead of the raw query
+        queryInfo.init({
+            document: query,
+            observableQuery: observable,
+            variables: observable.variables,
         });
         return observable;
-    }
-    query(options) {
-        const query = this.transform(options.query);
-        return this.fetchQuery({
-            ...options,
-            query,
-        }).then((value) => ({
-            ...value,
-            data: this.maskOperation({
-                document: query,
-                data: value?.data,
-                fetchPolicy: options.fetchPolicy,
-            }),
-        }));
-    }
-    requestIdCounter = 1;
-    generateRequestId() {
+    };
+    QueryManager.prototype.query = function (options, queryId) {
+        var _this = this;
+        if (queryId === void 0) { queryId = this.generateQueryId(); }
+        invariant(options.query, 38);
+        invariant(options.query.kind === "Document", 39);
+        invariant(!options.returnPartialData, 40);
+        invariant(!options.pollInterval, 41);
+        var query = this.transform(options.query);
+        return this.fetchQuery(queryId, __assign(__assign({}, options), { query: query }))
+            .then(function (result) {
+            return result && __assign(__assign({}, result), { data: _this.maskOperation({
+                    document: query,
+                    data: result.data,
+                    fetchPolicy: options.fetchPolicy,
+                    id: queryId,
+                }) });
+        })
+            .finally(function () { return _this.stopQuery(queryId); });
+    };
+    QueryManager.prototype.generateQueryId = function () {
+        return String(this.queryIdCounter++);
+    };
+    QueryManager.prototype.generateRequestId = function () {
         return this.requestIdCounter++;
-    }
-    clearStore(options = {
-        discardWatches: true,
-    }) {
+    };
+    QueryManager.prototype.generateMutationId = function () {
+        return String(this.mutationIdCounter++);
+    };
+    QueryManager.prototype.stopQueryInStore = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.broadcastQueries();
+    };
+    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
+        var queryInfo = this.queries.get(queryId);
+        if (queryInfo)
+            queryInfo.stop();
+    };
+    QueryManager.prototype.clearStore = function (options) {
+        if (options === void 0) { options = {
+            discardWatches: true,
+        }; }
         // Before we have sent the reset action to the store, we can no longer
         // rely on the results returned by in-flight requests since these may
         // depend on values that previously existed in the data portion of the
         // store. So, we cancel the promises and observers that we have issued
         // so far and not yet resolved (in the case of queries).
-        this.cancelPendingFetches(newInvariantError(87));
-        this.obsQueries.forEach((observableQuery) => {
-            // Set loading to true so listeners don't trigger unless they want
-            // results with partial data.
-            observableQuery.reset();
+        this.cancelPendingFetches(newInvariantError(42));
+        this.queries.forEach(function (queryInfo) {
+            if (queryInfo.observableQuery) {
+                // Set loading to true so listeners don't trigger unless they want
+                // results with partial data.
+                queryInfo.networkStatus = NetworkStatus.loading;
+            }
+            else {
+                queryInfo.stop();
+            }
         });
         if (this.mutationStore) {
-            this.mutationStore = {};
+            this.mutationStore = Object.create(null);
         }
         // begin removing data from the store
         return this.cache.reset(options);
-    }
-    getObservableQueries(include = "active") {
-        const queries = new Set();
-        const queryNames = new Map();
-        const queryNamesAndQueryStrings = new Map();
-        const legacyQueryOptions = new Set();
+    };
+    QueryManager.prototype.getObservableQueries = function (include) {
+        var _this = this;
+        if (include === void 0) { include = "active"; }
+        var queries = new Map();
+        var queryNames = new Map();
+        var queryNamesAndQueryStrings = new Map();
+        var legacyQueryOptions = new Set();
         if (Array.isArray(include)) {
-            include.forEach((desc) => {
+            include.forEach(function (desc) {
                 if (typeof desc === "string") {
                     queryNames.set(desc, desc);
                     queryNamesAndQueryStrings.set(desc, false);
                 }
                 else if (isDocumentNode(desc)) {
-                    const queryString = print(this.transform(desc));
+                    var queryString = print(_this.transform(desc));
                     queryNames.set(queryString, getOperationName(desc));
                     queryNamesAndQueryStrings.set(queryString, false);
                 }
@@ -375,383 +556,325 @@ export class QueryManager {
                 }
             });
         }
-        this.obsQueries.forEach((oq) => {
-            const document = print(this.transform(oq.options.query));
-            if (include === "all") {
-                queries.add(oq);
-                return;
-            }
-            const { queryName, options: { fetchPolicy }, } = oq;
-            if (include === "active" && fetchPolicy === "standby") {
-                return;
-            }
-            if (include === "active" ||
-                (queryName && queryNamesAndQueryStrings.has(queryName)) ||
-                (document && queryNamesAndQueryStrings.has(document))) {
-                queries.add(oq);
-                if (queryName)
-                    queryNamesAndQueryStrings.set(queryName, true);
-                if (document)
-                    queryNamesAndQueryStrings.set(document, true);
+        this.queries.forEach(function (_a, queryId) {
+            var oq = _a.observableQuery, document = _a.document;
+            if (oq) {
+                if (include === "all") {
+                    queries.set(queryId, oq);
+                    return;
+                }
+                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;
+                if (fetchPolicy === "standby" ||
+                    (include === "active" && !oq.hasObservers())) {
+                    return;
+                }
+                if (include === "active" ||
+                    (queryName && queryNamesAndQueryStrings.has(queryName)) ||
+                    (document && queryNamesAndQueryStrings.has(print(document)))) {
+                    queries.set(queryId, oq);
+                    if (queryName)
+                        queryNamesAndQueryStrings.set(queryName, true);
+                    if (document)
+                        queryNamesAndQueryStrings.set(print(document), true);
+                }
             }
         });
         if (legacyQueryOptions.size) {
-            legacyQueryOptions.forEach((options) => {
-                const oq = new ObservableQuery({
-                    queryManager: this,
-                    options: {
-                        ...options,
-                        fetchPolicy: "network-only",
-                    },
+            legacyQueryOptions.forEach(function (options) {
+                // We will be issuing a fresh network request for this query, so we
+                // pre-allocate a new query ID here, using a special prefix to enable
+                // cleaning up these temporary queries later, after fetching.
+                var queryId = makeUniqueId("legacyOneTimeQuery");
+                var queryInfo = _this.getOrCreateQuery(queryId).init({
+                    document: options.query,
+                    variables: options.variables,
+                });
+                var oq = new ObservableQuery({
+                    queryManager: _this,
+                    queryInfo: queryInfo,
+                    options: __assign(__assign({}, options), { fetchPolicy: "network-only" }),
                 });
-                queries.add(oq);
+                invariant(oq.queryId === queryId);
+                queryInfo.setObservableQuery(oq);
+                queries.set(queryId, oq);
             });
         }
-        if (__DEV__ && queryNamesAndQueryStrings.size) {
-            queryNamesAndQueryStrings.forEach((included, nameOrQueryString) => {
+        if (globalThis.__DEV__ !== false && queryNamesAndQueryStrings.size) {
+            queryNamesAndQueryStrings.forEach(function (included, nameOrQueryString) {
                 if (!included) {
-                    const queryName = queryNames.get(nameOrQueryString);
+                    var queryName = queryNames.get(nameOrQueryString);
                     if (queryName) {
-                        __DEV__ && invariant.warn(88, queryName);
+                        globalThis.__DEV__ !== false && invariant.warn(43, queryName);
                     }
                     else {
-                        __DEV__ && invariant.warn(89);
+                        globalThis.__DEV__ !== false && invariant.warn(44);
                     }
                 }
             });
         }
         return queries;
-    }
-    refetchObservableQueries(includeStandby = false) {
-        const observableQueryPromises = [];
-        this.getObservableQueries(includeStandby ? "all" : "active").forEach((observableQuery) => {
-            const { fetchPolicy } = observableQuery.options;
-            if ((includeStandby || fetchPolicy !== "standby") &&
-                fetchPolicy !== "cache-only") {
+    };
+    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
+        var _this = this;
+        if (includeStandby === void 0) { includeStandby = false; }
+        var observableQueryPromises = [];
+        this.getObservableQueries(includeStandby ? "all" : "active").forEach(function (observableQuery, queryId) {
+            var fetchPolicy = observableQuery.options.fetchPolicy;
+            muteDeprecations("resetLastResults", function () {
+                return observableQuery.resetLastResults();
+            });
+            if (includeStandby ||
+                (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
                 observableQueryPromises.push(observableQuery.refetch());
             }
+            (_this.queries.get(queryId) || observableQuery["queryInfo"]).setDiff(null);
         });
         this.broadcastQueries();
         return Promise.all(observableQueryPromises);
-    }
-    startGraphQLSubscription(options) {
-        let { query, variables } = options;
-        const { fetchPolicy, errorPolicy = "none", context = {}, extensions = {}, } = options;
-        checkDocument(query, OperationTypeNode.SUBSCRIPTION);
+    };
+    QueryManager.prototype.startGraphQLSubscription = function (options) {
+        var _this = this;
+        var query = options.query, variables = options.variables;
+        var fetchPolicy = options.fetchPolicy, _a = options.errorPolicy, errorPolicy = _a === void 0 ? "none" : _a, _b = options.context, context = _b === void 0 ? {} : _b, _c = options.extensions, extensions = _c === void 0 ? {} : _c;
         query = this.transform(query);
         variables = this.getVariables(query, variables);
-        let restart;
-        if (__DEV__) {
-            invariant(
-                !this.getDocumentInfo(query).hasClientExports || this.localState,
-                90,
-                getOperationName(query, "(anonymous)")
-            );
-        }
-        const observable = (this.getDocumentInfo(query).hasClientExports ?
-            from(this.localState.getExportedVariables({
-                client: this.client,
-                document: query,
-                variables,
-                context,
-            }))
-            : of(variables)).pipe(mergeMap((variables) => {
-            const { observable, restart: res } = this.getObservableFromLink(query, context, variables, extensions);
-            const queryInfo = new QueryInfo(this);
-            restart = res;
-            return observable.pipe(map((rawResult) => {
-                queryInfo.markSubscriptionResult(rawResult, {
-                    document: query,
-                    variables,
-                    errorPolicy,
-                    cacheWriteBehavior: fetchPolicy === "no-cache" ?
-                        0 /* CacheWriteBehavior.FORBID */
-                        : 2 /* CacheWriteBehavior.MERGE */,
-                });
-                const result = {
-                    data: rawResult.data ?? undefined,
-                };
-                if (graphQLResultHasError(rawResult)) {
-                    result.error = new CombinedGraphQLErrors(rawResult);
-                }
-                else if (graphQLResultHasProtocolErrors(rawResult)) {
-                    result.error = rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
-                    // Don't emit protocol errors added by HttpLink
-                    delete rawResult.extensions[PROTOCOL_ERRORS_SYMBOL];
-                }
-                if (rawResult.extensions &&
-                    Object.keys(rawResult.extensions).length) {
-                    result.extensions = rawResult.extensions;
+        var makeObservable = function (variables) {
+            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {
+                if (fetchPolicy !== "no-cache") {
+                    // the subscription interface should handle not sending us results we no longer subscribe to.
+                    // XXX I don't think we ever send in an object with errors, but we might in the future...
+                    if (shouldWriteResult(result, errorPolicy)) {
+                        _this.cache.write({
+                            query: query,
+                            result: result.data,
+                            dataId: "ROOT_SUBSCRIPTION",
+                            variables: variables,
+                        });
+                    }
+                    _this.broadcastQueries();
                 }
-                if (result.error && errorPolicy === "none") {
-                    result.data = undefined;
+                var hasErrors = graphQLResultHasError(result);
+                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
+                if (hasErrors || hasProtocolErrors) {
+                    var errors = {};
+                    if (hasErrors) {
+                        errors.graphQLErrors = result.errors;
+                    }
+                    if (hasProtocolErrors) {
+                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
+                    }
+                    // `errorPolicy` is a mechanism for handling GraphQL errors, according
+                    // to our documentation, so we throw protocol errors regardless of the
+                    // set error policy.
+                    if (errorPolicy === "none" || hasProtocolErrors) {
+                        throw new ApolloError(errors);
+                    }
                 }
                 if (errorPolicy === "ignore") {
-                    delete result.error;
+                    delete result.errors;
                 }
                 return result;
-            }), catchError((error) => {
-                if (errorPolicy === "ignore") {
-                    return of({ data: undefined });
-                }
-                return of({ data: undefined, error });
-            }), filter((result) => !!(result.data || result.error)));
-        }));
-        return Object.assign(observable, { restart: () => restart?.() });
-    }
-    broadcastQueries() {
+            });
+        };
+        if (this.getDocumentInfo(query).hasClientExports) {
+            var observablePromise_1 = this.localState
+                .addExportedVariables(query, variables, context)
+                .then(makeObservable);
+            return new Observable(function (observer) {
+                var sub = null;
+                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);
+                return function () { return sub && sub.unsubscribe(); };
+            });
+        }
+        return makeObservable(variables);
+    };
+    QueryManager.prototype.stopQuery = function (queryId) {
+        this.stopQueryNoBroadcast(queryId);
+        this.broadcastQueries();
+    };
+    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
+        this.stopQueryInStoreNoBroadcast(queryId);
+        this.removeQuery(queryId);
+    };
+    QueryManager.prototype.removeQuery = function (queryId) {
+        var _a;
+        // teardown all links
+        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises
+        // that each add their reject functions to fetchCancelFns.
+        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.
+        // The same queryId could have two rejection fns for two promises
+        this.fetchCancelFns.delete(queryId);
+        if (this.queries.has(queryId)) {
+            (_a = this.queries.get(queryId)) === null || _a === void 0 ? void 0 : _a.stop();
+            this.queries.delete(queryId);
+        }
+    };
+    QueryManager.prototype.broadcastQueries = function () {
         if (this.onBroadcast)
             this.onBroadcast();
-        this.obsQueries.forEach((observableQuery) => observableQuery.notify());
-    }
-    // Use protected instead of private field so
-    // @apollo/experimental-nextjs-app-support can access type info.
-    inFlightLinkObservables = new Trie(false);
-    getObservableFromLink(query, context, variables, extensions, 
+        this.queries.forEach(function (info) { var _a; return (_a = info.observableQuery) === null || _a === void 0 ? void 0 : _a["notify"](); });
+    };
+    QueryManager.prototype.getLocalState = function () {
+        return this.localState;
+    };
+    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions, 
     // Prefer context.queryDeduplication if specified.
-    deduplication = context?.queryDeduplication ??
-        this.queryDeduplication) {
-        let entry = {};
-        const { serverQuery, clientQuery, operationType, hasIncrementalDirective } = this.getDocumentInfo(query);
-        const operationName = getOperationName(query);
-        const executeContext = {
-            client: this.client,
-        };
+    deduplication) {
+        var _this = this;
+        var _a;
+        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }
+        var observable;
+        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;
         if (serverQuery) {
-            const { inFlightLinkObservables, link } = this;
-            try {
-                const operation = this.incrementalHandler.prepareRequest({
-                    query: serverQuery,
-                    variables,
-                    operationName,
-                    context: {
-                        ...this.defaultContext,
-                        ...context,
-                        queryDeduplication: deduplication,
-                    },
-                    extensions,
-                });
-                context = operation.context;
-                function withRestart(source) {
-                    return new Observable((observer) => {
-                        function subscribe() {
-                            return source.subscribe({
-                                next: observer.next.bind(observer),
-                                complete: observer.complete.bind(observer),
-                                error: observer.error.bind(observer),
-                            });
+            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;
+            var operation = {
+                query: serverQuery,
+                variables: variables,
+                operationName: getOperationName(serverQuery) || void 0,
+                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),
+                extensions: extensions,
+            };
+            context = operation.context;
+            if (deduplication) {
+                var printedServerQuery_1 = print(serverQuery);
+                var varJson_1 = canonicalStringify(variables);
+                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);
+                observable = entry.observable;
+                if (!observable) {
+                    var concast_1 = new Concast([
+                        execute(link, operation),
+                    ]);
+                    observable = entry.observable = concast_1;
+                    concast_1.beforeNext(function cb(method, arg) {
+                        if (method === "next" && "hasNext" in arg && arg.hasNext) {
+                            concast_1.beforeNext(cb);
+                        }
+                        else {
+                            inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);
                         }
-                        let subscription = subscribe();
-                        entry.restart ||= () => {
-                            subscription.unsubscribe();
-                            subscription = subscribe();
-                        };
-                        return () => {
-                            subscription.unsubscribe();
-                            entry.restart = undefined;
-                        };
                     });
                 }
-                if (deduplication) {
-                    const printedServerQuery = print(serverQuery);
-                    const varJson = canonicalStringify(variables);
-                    entry = inFlightLinkObservables.lookup(printedServerQuery, varJson);
-                    if (!entry.observable) {
-                        entry.observable = execute(link, operation, executeContext).pipe(withRestart, finalize(() => {
-                            if (inFlightLinkObservables.peek(printedServerQuery, varJson) ===
-                                entry) {
-                                inFlightLinkObservables.remove(printedServerQuery, varJson);
-                            }
-                        }), 
-                        // We don't want to replay the last emitted value for
-                        // subscriptions and instead opt to wait to receive updates until
-                        // the subscription emits new values.
-                        operationType === OperationTypeNode.SUBSCRIPTION ?
-                            share()
-                            : shareReplay({ refCount: true }));
-                    }
-                }
-                else {
-                    entry.observable = execute(link, operation, executeContext).pipe(withRestart);
-                }
             }
-            catch (error) {
-                entry.observable = throwError(() => error);
+            else {
+                observable = new Concast([
+                    execute(link, operation),
+                ]);
             }
         }
         else {
-            entry.observable = of({ data: {} });
+            observable = new Concast([Observable.of({ data: {} })]);
+            context = this.prepareContext(context);
         }
         if (clientQuery) {
-            const { operation } = getOperationDefinition(query);
-            if (__DEV__) {
-                invariant(
-                    this.localState,
-                    91,
-                    operation[0].toUpperCase() + operation.slice(1),
-                    operationName ?? "(anonymous)"
-                );
-            }
-            invariant(
-                !hasIncrementalDirective,
-                92,
-                operation[0].toUpperCase() + operation.slice(1),
-                operationName ?? "(anonymous)"
-            );
-            entry.observable = entry.observable.pipe(mergeMap((result) => {
-                return from(this.localState.execute({
-                    client: this.client,
+            observable = asyncMap(observable, function (result) {
+                return _this.localState.runResolvers({
                     document: clientQuery,
                     remoteResult: result,
-                    context,
-                    variables,
-                }));
-            }));
+                    context: context,
+                    variables: variables,
+                });
+            });
         }
-        return {
-            restart: () => entry.restart?.(),
-            observable: entry.observable.pipe(catchError((error) => {
-                error = toErrorLike(error);
-                registerLinkError(error);
-                throw error;
-            })),
-        };
-    }
-    getResultsFromLink(options, { queryInfo, cacheWriteBehavior, observableQuery, }) {
-        const requestId = (queryInfo.lastRequestId = this.generateRequestId());
-        const { errorPolicy } = options;
+        return observable;
+    };
+    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {
+        var requestId = (queryInfo.lastRequestId = this.generateRequestId());
         // Performing transformForLink here gives this.cache a chance to fill in
         // missing fragment definitions (for example) before sending this document
         // through the link chain.
-        const linkDocument = this.cache.transformForLink(options.query);
-        return this.getObservableFromLink(linkDocument, options.context, options.variables).observable.pipe(map((incoming) => {
-            // Use linkDocument rather than queryInfo.document so the
-            // operation/fragments used to write the result are the same as the
-            // ones used to obtain it from the link.
-            const result = queryInfo.markQueryResult(incoming, {
-                ...options,
-                document: linkDocument,
-                cacheWriteBehavior,
-            });
-            const hasErrors = graphQLResultHasError(result);
-            if (hasErrors && errorPolicy === "none") {
-                queryInfo.resetLastWrite();
-                observableQuery?.["resetNotifications"]();
-                throw new CombinedGraphQLErrors(result);
+        var linkDocument = this.cache.transformForLink(options.query);
+        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
+            var graphQLErrors = getGraphQLErrorsFromResult(result);
+            var hasErrors = graphQLErrors.length > 0;
+            var errorPolicy = options.errorPolicy;
+            // If we interrupted this request by calling getResultsFromLink again
+            // with the same QueryInfo object, we ignore the old results.
+            if (requestId >= queryInfo.lastRequestId) {
+                if (hasErrors && errorPolicy === "none") {
+                    // Throwing here effectively calls observer.error.
+                    throw queryInfo.markError(new ApolloError({
+                        graphQLErrors: graphQLErrors,
+                    }));
+                }
+                // Use linkDocument rather than queryInfo.document so the
+                // operation/fragments used to write the result are the same as the
+                // ones used to obtain it from the link.
+                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
+                queryInfo.markReady();
             }
-            const aqr = {
+            var aqr = {
                 data: result.data,
-                ...(queryInfo.hasNext ?
-                    {
-                        loading: true,
-                        networkStatus: NetworkStatus.streaming,
-                        dataState: "streaming",
-                        partial: true,
-                    }
-                    : {
-                        dataState: result.data ? "complete" : "empty",
-                        loading: false,
-                        networkStatus: NetworkStatus.ready,
-                        partial: !result.data,
-                    }),
+                loading: false,
+                networkStatus: NetworkStatus.ready,
             };
             // In the case we start multiple network requests simulatenously, we
             // want to ensure we properly set `data` if we're reporting on an old
             // result which will not be caught by the conditional above that ends up
             // throwing the markError result.
-            if (hasErrors) {
-                if (errorPolicy === "none") {
-                    aqr.data = void 0;
-                    aqr.dataState = "empty";
-                }
-                if (errorPolicy !== "ignore") {
-                    aqr.error = new CombinedGraphQLErrors(result);
-                    if (aqr.dataState !== "streaming") {
-                        aqr.networkStatus = NetworkStatus.error;
-                    }
-                }
+            if (hasErrors && errorPolicy === "none") {
+                aqr.data = void 0;
+            }
+            if (hasErrors && errorPolicy !== "ignore") {
+                aqr.errors = graphQLErrors;
+                aqr.networkStatus = NetworkStatus.error;
             }
             return aqr;
-        }), catchError((error) => {
+        }, function (networkError) {
+            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));
             // Avoid storing errors from older interrupted queries.
-            if (requestId >= queryInfo.lastRequestId && errorPolicy === "none") {
-                queryInfo.resetLastWrite();
-                observableQuery?.["resetNotifications"]();
-                throw error;
-            }
-            const aqr = {
-                data: undefined,
-                dataState: "empty",
-                loading: false,
-                networkStatus: NetworkStatus.ready,
-                partial: true,
-            };
-            if (errorPolicy !== "ignore") {
-                aqr.error = error;
-                aqr.networkStatus = NetworkStatus.error;
+            if (requestId >= queryInfo.lastRequestId) {
+                queryInfo.markError(error);
             }
-            return of(aqr);
-        }));
-    }
-    fetchObservableWithInfo(options, { 
+            throw error;
+        });
+    };
+    QueryManager.prototype.fetchConcastWithInfo = function (queryInfo, options, 
     // The initial networkStatus for this fetch, most often
     // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
     // or setVariables.
-    networkStatus = NetworkStatus.loading, query = options.query, fetchQueryOperator = (x) => x, onCacheHit = () => { }, observableQuery, }) {
-        const variables = this.getVariables(query, options.variables);
-        const defaults = this.defaultOptions.watchQuery;
-        let { fetchPolicy = (defaults && defaults.fetchPolicy) || "cache-first", errorPolicy = (defaults && defaults.errorPolicy) || "none", returnPartialData = false, notifyOnNetworkStatusChange = true, context = {}, } = options;
-        if (this.prioritizeCacheValues &&
-            (fetchPolicy === "network-only" || fetchPolicy === "cache-and-network")) {
-            fetchPolicy = "cache-first";
-        }
-        const normalized = Object.assign({}, options, {
-            query,
-            variables,
-            fetchPolicy,
-            errorPolicy,
-            returnPartialData,
-            notifyOnNetworkStatusChange,
-            context,
+    networkStatus, query) {
+        var _this = this;
+        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }
+        if (query === void 0) { query = options.query; }
+        var variables = this.getVariables(query, options.variables);
+        var defaults = this.defaultOptions.watchQuery;
+        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || "cache-first" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || "none" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;
+        var normalized = Object.assign({}, options, {
+            query: query,
+            variables: variables,
+            fetchPolicy: fetchPolicy,
+            errorPolicy: errorPolicy,
+            returnPartialData: returnPartialData,
+            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,
+            context: context,
         });
-        const queryInfo = new QueryInfo(this, observableQuery);
-        const fromVariables = (variables) => {
+        var fromVariables = function (variables) {
             // Since normalized is always a fresh copy of options, it's safe to
             // modify its properties here, rather than creating yet another new
             // WatchQueryOptions object.
             normalized.variables = variables;
-            const cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 /* CacheWriteBehavior.FORBID */
-                // Watched queries must opt into overwriting existing data on refetch,
-                // by passing refetchWritePolicy: "overwrite" in their WatchQueryOptions.
-                : (networkStatus === NetworkStatus.refetch &&
-                    normalized.refetchWritePolicy !== "merge") ?
-                    1 /* CacheWriteBehavior.OVERWRITE */
-                    : 2 /* CacheWriteBehavior.MERGE */;
-            const observableWithInfo = this.fetchQueryByPolicy(normalized, { queryInfo, cacheWriteBehavior, onCacheHit, observableQuery });
-            observableWithInfo.observable =
-                observableWithInfo.observable.pipe(fetchQueryOperator);
+            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
             if (
             // If we're in standby, postpone advancing options.fetchPolicy using
             // applyNextFetchPolicy.
-            normalized.fetchPolicy !== "standby") {
-                observableQuery?.["applyNextFetchPolicy"]("after-fetch", options);
+            normalized.fetchPolicy !== "standby" &&
+                // The "standby" policy currently returns [] from fetchQueryByPolicy, so
+                // this is another way to detect when nothing was done/fetched.
+                sourcesWithInfo.sources.length > 0 &&
+                queryInfo.observableQuery) {
+                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
             }
-            return observableWithInfo;
+            return sourcesWithInfo;
         };
         // This cancel function needs to be set before the concast is created,
         // in case concast creation synchronously cancels the request.
-        const cleanupCancelFn = () => {
-            this.fetchCancelFns.delete(queryInfo.id);
-        };
-        this.fetchCancelFns.set(queryInfo.id, (error) => {
-            fetchCancelSubject.next({
-                kind: "E",
-                error,
-                source: "network",
-            });
+        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryInfo.queryId); };
+        this.fetchCancelFns.set(queryInfo.queryId, function (reason) {
+            cleanupCancelFn();
+            // This delay ensures the concast variable has been initialized.
+            setTimeout(function () { return concast.cancel(reason); });
         });
-        const fetchCancelSubject = new Subject();
-        let observable, containsDataFromLink;
+        var concast, containsDataFromLink;
         // If the query has @export(as: ...) directives, then we need to
         // process those directives asynchronously. When there are no
         // @export directives (the common case), we deliberately avoid
@@ -760,15 +883,10 @@ export class QueryManager {
         // for backwards compatibility. TODO This code could be simpler if
         // we deprecated and removed LocalState.
         if (this.getDocumentInfo(normalized.query).hasClientExports) {
-            if (__DEV__) {
-                invariant(this.localState, 93, getOperationName(normalized.query, "(anonymous)"));
-            }
-            observable = from(this.localState.getExportedVariables({
-                client: this.client,
-                document: normalized.query,
-                variables: normalized.variables,
-                context: normalized.context,
-            })).pipe(mergeMap((variables) => fromVariables(variables).observable));
+            concast = new Concast(this.localState
+                .addExportedVariables(normalized.query, normalized.variables, normalized.context)
+                .then(fromVariables)
+                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
             // there is just no way we can synchronously get the *right* value here,
             // so we will assume `true`, which is the behaviour before the bug fix in
             // #10597. This means that bug is not fixed in that case, and is probably
@@ -777,41 +895,30 @@ export class QueryManager {
             containsDataFromLink = true;
         }
         else {
-            const sourcesWithInfo = fromVariables(normalized.variables);
+            var sourcesWithInfo = fromVariables(normalized.variables);
             containsDataFromLink = sourcesWithInfo.fromLink;
-            observable = sourcesWithInfo.observable;
+            concast = new Concast(sourcesWithInfo.sources);
         }
+        concast.promise.then(cleanupCancelFn, cleanupCancelFn);
         return {
-            // Merge `observable` with `fetchCancelSubject`, in a way that completing or
-            // erroring either of them will complete the merged obserable.
-            observable: new Observable((observer) => {
-                observer.add(cleanupCancelFn);
-                observable.subscribe(observer);
-                fetchCancelSubject.subscribe(observer);
-            }).pipe(share()),
+            concast: concast,
             fromLink: containsDataFromLink,
         };
-    }
-    refetchQueries({ updateCache, include, optimistic = false, removeOptimistic = optimistic ? makeUniqueId("refetchQueries") : void 0, onQueryUpdated, }) {
-        const includedQueriesByOq = new Map();
+    };
+    QueryManager.prototype.refetchQueries = function (_a) {
+        var _this = this;
+        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId("refetchQueries") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;
+        var includedQueriesById = new Map();
         if (include) {
-            this.getObservableQueries(include).forEach((oq) => {
-                if (oq.options.fetchPolicy === "cache-only") {
-                    return;
-                }
-                const current = oq.getCurrentResult();
-                includedQueriesByOq.set(oq, {
-                    oq,
-                    lastDiff: {
-                        result: current?.data,
-                        complete: !current?.partial,
-                    },
+            this.getObservableQueries(include).forEach(function (oq, queryId) {
+                includedQueriesById.set(queryId, {
+                    oq: oq,
+                    lastDiff: (_this.queries.get(queryId) || oq["queryInfo"]).getDiff(),
                 });
             });
         }
-        const results = new Map();
+        var results = new Map();
         if (updateCache) {
-            const handled = new Set();
             this.cache.batch({
                 update: updateCache,
                 // Since you can perform any combination of cache reads and/or writes in
@@ -851,23 +958,20 @@ export class QueryManager {
                 // If an explicit removeOptimistic string is provided with optimistic:
                 // true, the removeOptimistic string will determine the ID of the
                 // temporary optimistic layer, in case that ever matters.
-                removeOptimistic,
-                onWatchUpdated(watch, diff, lastDiff) {
-                    const oq = watch.watcher;
-                    if (oq instanceof ObservableQuery && !handled.has(oq)) {
-                        handled.add(oq);
+                removeOptimistic: removeOptimistic,
+                onWatchUpdated: function (watch, diff, lastDiff) {
+                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
+                    if (oq) {
                         if (onQueryUpdated) {
                             // Since we're about to handle this query now, remove it from
                             // includedQueriesById, in case it was added earlier because of
                             // options.include.
-                            includedQueriesByOq.delete(oq);
-                            let result = onQueryUpdated(oq, diff, lastDiff);
+                            includedQueriesById.delete(oq.queryId);
+                            var result = onQueryUpdated(oq, diff, lastDiff);
                             if (result === true) {
                                 // The onQueryUpdated function requested the default refetching
                                 // behavior by returning true.
-                                result = oq
-                                    .refetch()
-                                    .retain( /* create a persistent subscription on the query */);
+                                result = oq.refetch();
                             }
                             // Record the result in the results Map, as long as onQueryUpdated
                             // did not return false to skip/ignore this result.
@@ -878,37 +982,40 @@ export class QueryManager {
                             // onQueryUpdated returns false.
                             return result;
                         }
-                        if (onQueryUpdated !== null &&
-                            oq.options.fetchPolicy !== "cache-only") {
+                        if (onQueryUpdated !== null) {
                             // If we don't have an onQueryUpdated function, and onQueryUpdated
                             // was not disabled by passing null, make sure this query is
                             // "included" like any other options.include-specified query.
-                            includedQueriesByOq.set(oq, { oq, lastDiff, diff });
+                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
                         }
                     }
                 },
             });
         }
-        if (includedQueriesByOq.size) {
-            includedQueriesByOq.forEach(({ oq, lastDiff, diff }) => {
-                let result;
+        if (includedQueriesById.size) {
+            includedQueriesById.forEach(function (_a, queryId) {
+                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;
+                var result;
                 // If onQueryUpdated is provided, we want to use it for all included
                 // queries, even the QueryOptions ones.
                 if (onQueryUpdated) {
                     if (!diff) {
-                        diff = oq.getCacheDiff();
+                        diff = muteDeprecations("canonizeResults", function () {
+                            return _this.cache.diff(oq["queryInfo"]["getDiffOptions"]());
+                        });
                     }
                     result = onQueryUpdated(oq, diff, lastDiff);
                 }
                 // Otherwise, we fall back to refetching.
                 if (!onQueryUpdated || result === true) {
-                    result = oq
-                        .refetch()
-                        .retain( /* create a persistent subscription on the query */);
+                    result = oq.refetch();
                 }
                 if (result !== false) {
                     results.set(oq, result);
                 }
+                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
+                    _this.stopQueryNoBroadcast(queryId);
+                }
             });
         }
         if (removeOptimistic) {
@@ -922,92 +1029,68 @@ export class QueryManager {
             this.cache.removeOptimistic(removeOptimistic);
         }
         return results;
-    }
-    noCacheWarningsByCause = new WeakSet();
-    maskOperation(options) {
-        const { document, data } = options;
-        if (__DEV__) {
-            const { fetchPolicy, cause = {} } = options;
-            const operationType = getOperationDefinition(document)?.operation;
+    };
+    QueryManager.prototype.maskOperation = function (options) {
+        var _a, _b, _c;
+        var document = options.document, data = options.data;
+        if (globalThis.__DEV__ !== false) {
+            var fetchPolicy = options.fetchPolicy, id = options.id;
+            var operationType = (_a = getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation;
+            var operationId = ((_b = operationType === null || operationType === void 0 ? void 0 : operationType[0]) !== null && _b !== void 0 ? _b : "o") + id;
             if (this.dataMasking &&
                 fetchPolicy === "no-cache" &&
                 !isFullyUnmaskedOperation(document) &&
-                !this.noCacheWarningsByCause.has(cause)) {
-                this.noCacheWarningsByCause.add(cause);
-                __DEV__ && invariant.warn(94, getOperationName(document, `Unnamed ${operationType ?? "operation"}`));
+                !this.noCacheWarningsByQueryId.has(operationId)) {
+                this.noCacheWarningsByQueryId.add(operationId);
+                globalThis.__DEV__ !== false && invariant.warn(
+                    45,
+                    (_c = getOperationName(document)) !== null && _c !== void 0 ? _c : "Unnamed ".concat(operationType !== null && operationType !== void 0 ? operationType : "operation")
+                );
             }
         }
         return (this.dataMasking ?
             maskOperation(data, document, this.cache)
             : data);
-    }
-    maskFragment(options) {
-        const { data, fragment, fragmentName } = options;
+    };
+    QueryManager.prototype.maskFragment = function (options) {
+        var data = options.data, fragment = options.fragment, fragmentName = options.fragmentName;
         return this.dataMasking ?
             maskFragment(data, fragment, this.cache, fragmentName)
             : data;
-    }
-    fetchQueryByPolicy({ query, variables, fetchPolicy, errorPolicy, returnPartialData, context, }, { cacheWriteBehavior, onCacheHit, queryInfo, observableQuery, }) {
-        const readCache = () => this.cache.diff({
-            query,
-            variables,
-            returnPartialData: true,
-            optimistic: true,
+    };
+    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, 
+    // The initial networkStatus for this fetch, most often
+    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
+    // or setVariables.
+    networkStatus) {
+        var _this = this;
+        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
+        var oldNetworkStatus = queryInfo.networkStatus;
+        queryInfo.init({
+            document: query,
+            variables: variables,
+            networkStatus: networkStatus,
         });
-        const resultsFromCache = (diff, networkStatus) => {
-            const data = diff.result;
-            if (__DEV__ && !returnPartialData && data !== null) {
+        var readCache = function () { return queryInfo.getDiff(); };
+        var resultsFromCache = function (diff, networkStatus) {
+            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }
+            var data = diff.result;
+            if (globalThis.__DEV__ !== false && !returnPartialData && !equal(data, {})) {
                 logMissingFieldErrors(diff.missing);
             }
-            const toResult = (data) => {
-                // TODO: Eventually we should move this handling into
-                // queryInfo.getDiff() directly. Since getDiff is updated to return null
-                // on returnPartialData: false, we should take advantage of that instead
-                // of having to patch it elsewhere.
-                if (!diff.complete && !returnPartialData) {
-                    data = undefined;
-                }
-                return {
-                    // TODO: Handle partial data
-                    data: data,
-                    dataState: diff.complete ? "complete"
-                        : data ? "partial"
-                            : "empty",
-                    loading: isNetworkRequestInFlight(networkStatus),
-                    networkStatus,
-                    partial: !diff.complete,
-                };
+            var fromData = function (data) {
+                return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));
             };
-            const fromData = (data) => {
-                return of({
-                    kind: "N",
-                    value: toResult(data),
-                    source: "cache",
-                });
-            };
-            if (
-            // Don't attempt to run forced resolvers if we have incomplete cache
-            // data and partial isn't allowed since this result would get set to
-            // `undefined` anyways in `toResult`.
-            (diff.complete || returnPartialData) &&
-                this.getDocumentInfo(query).hasForcedResolvers) {
-                if (__DEV__) {
-                    invariant(this.localState, 95, getOperationName(query, "(anonymous)"));
-                }
-                onCacheHit();
-                return from(this.localState.execute({
-                    client: this.client,
+            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {
+                return _this.localState
+                    .runResolvers({
                     document: query,
-                    remoteResult: data ? { data } : undefined,
-                    context,
-                    variables,
+                    remoteResult: { data: data },
+                    context: context,
+                    variables: variables,
                     onlyRunForcedResolvers: true,
-                    returnPartialData: true,
-                }).then((resolved) => ({
-                    kind: "N",
-                    value: toResult(resolved.data || void 0),
-                    source: "cache",
-                })));
+                })
+                    .then(function (resolved) { return fromData(resolved.data || void 0); });
             }
             // Resolves https://github.com/apollographql/apollo-client/issues/10317.
             // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,
@@ -1015,111 +1098,99 @@ export class QueryManager {
             // if diff.missing exists, we should not return cache data.
             if (errorPolicy === "none" &&
                 networkStatus === NetworkStatus.refetch &&
-                diff.missing) {
+                Array.isArray(diff.missing)) {
                 return fromData(void 0);
             }
-            return fromData(data || undefined);
+            return fromData(data);
+        };
+        var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 /* CacheWriteBehavior.FORBID */
+            // Watched queries must opt into overwriting existing data on refetch,
+            // by passing refetchWritePolicy: "overwrite" in their WatchQueryOptions.
+            : (networkStatus === NetworkStatus.refetch &&
+                refetchWritePolicy !== "merge") ?
+                1 /* CacheWriteBehavior.OVERWRITE */
+                : 2 /* CacheWriteBehavior.MERGE */;
+        var resultsFromLink = function () {
+            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
+                query: query,
+                variables: variables,
+                context: context,
+                fetchPolicy: fetchPolicy,
+                errorPolicy: errorPolicy,
+            });
         };
-        const resultsFromLink = () => this.getResultsFromLink({
-            query,
-            variables,
-            context,
-            fetchPolicy,
-            errorPolicy,
-        }, {
-            cacheWriteBehavior,
-            queryInfo,
-            observableQuery,
-        }).pipe(validateDidEmitValue(), materialize(), map((result) => ({
-            ...result,
-            source: "network",
-        })));
+        var shouldNotify = notifyOnNetworkStatusChange &&
+            typeof oldNetworkStatus === "number" &&
+            oldNetworkStatus !== networkStatus &&
+            isNetworkRequestInFlight(networkStatus);
         switch (fetchPolicy) {
             default:
             case "cache-first": {
-                const diff = readCache();
+                var diff = readCache();
                 if (diff.complete) {
                     return {
                         fromLink: false,
-                        observable: resultsFromCache(diff, NetworkStatus.ready),
+                        sources: [resultsFromCache(diff, queryInfo.markReady())],
                     };
                 }
-                if (returnPartialData) {
+                if (returnPartialData || shouldNotify) {
                     return {
                         fromLink: true,
-                        observable: concat(resultsFromCache(diff, NetworkStatus.loading), resultsFromLink()),
+                        sources: [resultsFromCache(diff), resultsFromLink()],
                     };
                 }
-                return { fromLink: true, observable: resultsFromLink() };
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-and-network": {
-                const diff = readCache();
-                if (diff.complete || returnPartialData) {
+                var diff = readCache();
+                if (diff.complete || returnPartialData || shouldNotify) {
                     return {
                         fromLink: true,
-                        observable: concat(resultsFromCache(diff, NetworkStatus.loading), resultsFromLink()),
+                        sources: [resultsFromCache(diff), resultsFromLink()],
                     };
                 }
-                return { fromLink: true, observable: resultsFromLink() };
+                return { fromLink: true, sources: [resultsFromLink()] };
             }
             case "cache-only":
                 return {
                     fromLink: false,
-                    observable: concat(resultsFromCache(readCache(), NetworkStatus.ready)),
+                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],
                 };
             case "network-only":
-                return { fromLink: true, observable: resultsFromLink() };
+                if (shouldNotify) {
+                    return {
+                        fromLink: true,
+                        sources: [resultsFromCache(readCache()), resultsFromLink()],
+                    };
+                }
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "no-cache":
-                return { fromLink: true, observable: resultsFromLink() };
+                if (shouldNotify) {
+                    return {
+                        fromLink: true,
+                        // Note that queryInfo.getDiff() for no-cache queries does not call
+                        // cache.diff, but instead returns a { complete: false } stub result
+                        // when there is no queryInfo.diff already defined.
+                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],
+                    };
+                }
+                return { fromLink: true, sources: [resultsFromLink()] };
             case "standby":
-                return { fromLink: false, observable: EMPTY };
+                return { fromLink: false, sources: [] };
         }
-    }
-}
-function validateDidEmitValue() {
-    let didEmitValue = false;
-    return tap({
-        next() {
-            didEmitValue = true;
-        },
-        complete() {
-            invariant(didEmitValue, 96);
-        },
-    });
-}
-function isFullyUnmaskedOperation(document) {
-    let isUnmasked = true;
-    visit(document, {
-        FragmentSpread: (node) => {
-            isUnmasked =
-                !!node.directives &&
-                    node.directives.some((directive) => directive.name.value === "unmask");
-            if (!isUnmasked) {
-                return BREAK;
-            }
-        },
-    });
-    return isUnmasked;
-}
-function addNonReactiveToNamedFragments(document) {
-    return visit(document, {
-        FragmentSpread: (node) => {
-            // Do not add `@nonreactive` if the fragment is marked with `@unmask`
-            // since we want to react to changes in this fragment.
-            if (node.directives?.some((directive) => directive.name.value === "unmask")) {
-                return;
-            }
-            return {
-                ...node,
-                directives: [
-                    ...(node.directives || []),
-                    {
-                        kind: Kind.DIRECTIVE,
-                        name: { kind: Kind.NAME, value: "nonreactive" },
-                    },
-                ],
-            };
-        },
-    });
-}
-//# sourceMappingURL=QueryManager.js.map
+    };
+    QueryManager.prototype.getOrCreateQuery = function (queryId) {
+        if (queryId && !this.queries.has(queryId)) {
+            this.queries.set(queryId, new QueryInfo(this, queryId));
+        }
+        return this.queries.get(queryId);
+    };
+    QueryManager.prototype.prepareContext = function (context) {
+        if (context === void 0) { context = {}; }
+        var newContext = this.localState.prepareContext(context);
+        return __assign(__assign(__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });
+    };
+    return QueryManager;
+}());
+export { QueryManager };
+//# sourceMappingURL=QueryManager.js.map