@apollo/client 3.13.4 → 4.0.0-alpha.1

package/core/ObservableQuery.js

@@ -1,147 +1,138 @@
-import { __assign, __extends } from "tslib";
-import { invariant } from "../utilities/globals/index.js";
 import { equal } from "@wry/equality";
-import { NetworkStatus, isNetworkRequestInFlight } from "./networkStatus.js";
-import { cloneDeep, compact, getOperationDefinition, Observable, iterateObserversSafely, fixObservableSubclass, getQueryDefinition, preventUnhandledRejection, } from "../utilities/index.js";
-import { ApolloError, isApolloError } from "../errors/index.js";
+import { BehaviorSubject, filter, lastValueFrom, tap } from "rxjs";
+import { cloneDeep, compact, getOperationDefinition, getQueryDefinition, preventUnhandledRejection, } from "@apollo/client/utilities";
+import { __DEV__ } from "@apollo/client/utilities/environment";
+import { invariant } from "@apollo/client/utilities/invariant";
 import { equalByQuery } from "./equalByQuery.js";
-var assign = Object.assign, hasOwnProperty = Object.hasOwnProperty;
-var ObservableQuery = /** @class */ (function (_super) {
-    __extends(ObservableQuery, _super);
-    function ObservableQuery(_a) {
-        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;
-        var _this = _super.call(this, function (observer) {
-            // Zen Observable has its own error function, so in order to log correctly
-            // we need to provide a custom error callback.
-            try {
-                var subObserver = observer._subscription._observer;
-                if (subObserver && !subObserver.error) {
-                    subObserver.error = defaultSubscriptionObserverErrorCallback;
+import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
+const { assign, hasOwnProperty } = Object;
+export class ObservableQuery {
+    options;
+    queryId;
+    queryName;
+    // The `query` computed property will always reflect the document transformed
+    // by the last run query. `this.options.query` will always reflect the raw
+    // untransformed query to ensure document transforms with runtime conditionals
+    // are run on the original document.
+    get query() {
+        return this.lastQuery || this.options.query;
+    }
+    // Computed shorthand for this.options.variables, preserved for
+    // backwards compatibility.
+    /**
+     * An object containing the variables that were provided for the query.
+     */
+    get variables() {
+        return this.options.variables;
+    }
+    subject;
+    observable;
+    initialResult;
+    isTornDown;
+    queryManager;
+    subscriptions = new Set();
+    waitForOwnResult;
+    last;
+    lastQuery;
+    queryInfo;
+    linkSubscription;
+    linkObservable;
+    pollingInfo;
+    networkStatus;
+    constructor({ queryManager, queryInfo, options, }) {
+        this.networkStatus = NetworkStatus.loading;
+        this.initialResult = {
+            data: undefined,
+            loading: true,
+            networkStatus: this.networkStatus,
+            partial: true,
+        };
+        this.subject = new BehaviorSubject(this.initialResult);
+        this.observable = this.subject.pipe(tap({
+            subscribe: () => {
+                if (!this.subject.observed) {
+                    this.reobserve();
+                    // TODO: See if we can rework updatePolling to better handle this.
+                    // reobserve calls updatePolling but this `subscribe` callback is
+                    // called before the subject is subscribed to so `updatePolling`
+                    // can't accurately detect if there is an active subscription.
+                    // Calling it again here ensures that it can detect if it can poll
+                    setTimeout(() => this.updatePolling());
                 }
-            }
-            catch (_a) { }
-            var first = !_this.observers.size;
-            _this.observers.add(observer);
-            // Deliver most recent error or result.
-            var last = _this.last;
-            if (last && last.error) {
-                observer.error && observer.error(last.error);
-            }
-            else if (last && last.result) {
-                observer.next && observer.next(_this.maskResult(last.result));
-            }
-            // Initiate observation of this query if it hasn't been reported to
-            // the QueryManager yet.
-            if (first) {
-                // Blindly catching here prevents unhandled promise rejections,
-                // and is safe because the ObservableQuery handles this error with
-                // this.observer.error, so we're not just swallowing the error by
-                // ignoring it here.
-                _this.reobserve().catch(function () { });
-            }
-            return function () {
-                if (_this.observers.delete(observer) && !_this.observers.size) {
-                    _this.tearDownQuery();
+            },
+            unsubscribe: () => {
+                if (!this.subject.observed) {
+                    this.tearDownQuery();
                 }
-            };
-        }) || this;
-        _this.observers = new Set();
-        _this.subscriptions = new Set();
+            },
+        }), 
+        // TODO: Conditionally filter when notifyOnNetworkStatusChange is true or
+        // not. We want to emit the loading result if notifyOnNetworkStatusChange
+        // is true.
+        filter((result) => 
+        // TODO: Remove this behavior when unifying loading state for notifyOnNetworkStatusChange
+        (this.options.fetchPolicy === "no-cache" &&
+            this.options.notifyOnNetworkStatusChange) ||
+            // TODO: Remove this behavior when unifying loading state for notifyOnNetworkStatusChange
+            (this.options.fetchPolicy === "network-only" &&
+                this.queryInfo.getDiff().complete) ||
+            result !== this.initialResult));
+        this["@@observable"] = () => this;
+        if (Symbol.observable) {
+            this[Symbol.observable] = () => this;
+        }
+        this.pipe = this.observable.pipe.bind(this.observable);
+        this.subscribe = this.observable.subscribe.bind(this.observable);
         // related classes
-        _this.queryInfo = queryInfo;
-        _this.queryManager = queryManager;
+        this.queryInfo = queryInfo;
+        this.queryManager = queryManager;
         // active state
-        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
-        _this.isTornDown = false;
-        _this.subscribeToMore = _this.subscribeToMore.bind(_this);
-        _this.maskResult = _this.maskResult.bind(_this);
-        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? "cache-first" : _d;
-        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, 
-        // Make sure we don't store "standby" as the initialFetchPolicy.
-        _f = options.initialFetchPolicy, 
+        this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
+        this.isTornDown = false;
+        this.subscribe = this.subscribe.bind(this);
+        this.subscribeToMore = this.subscribeToMore.bind(this);
+        this.maskResult = this.maskResult.bind(this);
+        const { watchQuery: { fetchPolicy: defaultFetchPolicy = "cache-first" } = {}, } = queryManager.defaultOptions;
+        const { fetchPolicy = defaultFetchPolicy, 
         // Make sure we don't store "standby" as the initialFetchPolicy.
-        initialFetchPolicy = _f === void 0 ? fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy) : _f;
-        _this.options = __assign(__assign({}, options), { 
+        initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
+        this.options = {
+            ...options,
             // Remember the initial options.fetchPolicy so we can revert back to this
             // policy when variables change. This information can also be specified
             // (or overridden) by providing options.initialFetchPolicy explicitly.
-            initialFetchPolicy: initialFetchPolicy, 
+            initialFetchPolicy,
             // This ensures this.options.fetchPolicy always has a string value, in
             // case options.fetchPolicy was not provided.
-            fetchPolicy: fetchPolicy });
-        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();
-        var opDef = getOperationDefinition(_this.query);
-        _this.queryName = opDef && opDef.name && opDef.name.value;
-        return _this;
-    }
-    Object.defineProperty(ObservableQuery.prototype, "query", {
-        // The `query` computed property will always reflect the document transformed
-        // by the last run query. `this.options.query` will always reflect the raw
-        // untransformed query to ensure document transforms with runtime conditionals
-        // are run on the original document.
-        get: function () {
-            return this.lastQuery || this.options.query;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObservableQuery.prototype, "variables", {
-        // Computed shorthand for this.options.variables, preserved for
-        // backwards compatibility.
-        /**
-         * An object containing the variables that were provided for the query.
-         */
-        get: function () {
-            return this.options.variables;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ObservableQuery.prototype.result = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            // TODO: this code doesn’t actually make sense insofar as the observer
-            // will never exist in this.observers due how zen-observable wraps observables.
-            // https://github.com/zenparsing/zen-observable/blob/master/src/Observable.js#L169
-            var observer = {
-                next: function (result) {
-                    resolve(result);
-                    // Stop the query within the QueryManager if we can before
-                    // this function returns.
-                    //
-                    // We do this in order to prevent observers piling up within
-                    // the QueryManager. Notice that we only fully unsubscribe
-                    // from the subscription in a setTimeout(..., 0)  call. This call can
-                    // actually be handled by the browser at a much later time. If queries
-                    // are fired in the meantime, observers that should have been removed
-                    // from the QueryManager will continue to fire, causing an unnecessary
-                    // performance hit.
-                    _this.observers.delete(observer);
-                    if (!_this.observers.size) {
-                        _this.queryManager.removeQuery(_this.queryId);
-                    }
-                    setTimeout(function () {
-                        subscription.unsubscribe();
-                    }, 0);
-                },
-                error: reject,
-            };
-            var subscription = _this.subscribe(observer);
-        });
-    };
+            fetchPolicy,
+        };
+        this.queryId = queryInfo.queryId || queryManager.generateQueryId();
+        const opDef = getOperationDefinition(this.query);
+        this.queryName = opDef && opDef.name && opDef.name.value;
+    }
+    // We can't use Observable['subscribe'] here as the type as it conflicts with
+    // the ability to infer T from Subscribable<T>. This limits the surface area
+    // to the non-deprecated signature which works properly with type inference.
+    subscribe;
+    pipe;
+    [Symbol.observable];
+    ["@@observable"];
     /** @internal */
-    ObservableQuery.prototype.resetDiff = function () {
+    resetDiff() {
         this.queryInfo.resetDiff();
-    };
-    ObservableQuery.prototype.getCurrentFullResult = function (saveAsLastResult) {
-        if (saveAsLastResult === void 0) { saveAsLastResult = true; }
+    }
+    getCurrentFullResult(saveAsLastResult = true) {
         // Use the last result as long as the variables match this.variables.
-        var lastResult = this.getLastResult(true);
-        var networkStatus = this.queryInfo.networkStatus ||
-            (lastResult && lastResult.networkStatus) ||
-            NetworkStatus.ready;
-        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
-        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
+        const lastResult = this.getLastResult(true);
+        const networkStatus = this.networkStatus;
+        const result = {
+            data: undefined,
+            partial: true,
+            ...lastResult,
+            loading: isNetworkRequestInFlight(networkStatus),
+            networkStatus,
+        };
+        const { fetchPolicy = "cache-first" } = this.options;
         if (
         // These fetch policies should never deliver data from the cache, unless
         // redelivering a previously delivered result.
@@ -160,17 +151,15 @@ var ObservableQuery = /** @class */ (function (_super) {
             this.queryInfo["updateWatch"]();
         }
         else {
-            var diff = this.queryInfo.getDiff();
+            const diff = this.queryInfo.getDiff();
+            result.partial = !diff.complete;
             if (diff.complete || this.options.returnPartialData) {
                 result.data = diff.result;
             }
-            if (equal(result.data, {})) {
+            if (result.data === null) {
                 result.data = void 0;
             }
             if (diff.complete) {
-                // Similar to setting result.partial to false, but taking advantage of the
-                // falsiness of missing fields.
-                delete result.partial;
                 // If the diff is complete, and we're using a FetchPolicy that
                 // terminates after a complete cache read, we can assume the next result
                 // we receive will have NetworkStatus.ready and !loading.
@@ -181,20 +170,15 @@ var ObservableQuery = /** @class */ (function (_super) {
                     result.loading = false;
                 }
             }
-            else {
-                result.partial = true;
-            }
             // We need to check for both both `error` and `errors` field because there
             // are cases where sometimes `error` is set, but not `errors` and
             // vice-versa. This will be updated in the next major version when
             // `errors` is deprecated in favor of `error`.
-            if (result.networkStatus === NetworkStatus.ready &&
-                (result.error || result.errors)) {
+            if (result.networkStatus === NetworkStatus.ready && result.error) {
                 result.networkStatus = NetworkStatus.error;
             }
-            if (globalThis.__DEV__ !== false &&
+            if (__DEV__ &&
                 !diff.complete &&
-                !this.options.partialRefetch &&
                 !result.loading &&
                 !result.data &&
                 !result.error) {
@@ -205,46 +189,47 @@ var ObservableQuery = /** @class */ (function (_super) {
             this.updateLastResult(result);
         }
         return result;
-    };
-    ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {
-        if (saveAsLastResult === void 0) { saveAsLastResult = true; }
+    }
+    getCurrentResult(saveAsLastResult = true) {
         return this.maskResult(this.getCurrentFullResult(saveAsLastResult));
-    };
+    }
     // Compares newResult to the snapshot we took of this.lastResult when it was
     // first received.
-    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
+    isDifferentFromLastResult(newResult, variables) {
         if (!this.last) {
             return true;
         }
-        var documentInfo = this.queryManager.getDocumentInfo(this.query);
-        var dataMasking = this.queryManager.dataMasking;
-        var query = dataMasking ? documentInfo.nonReactiveQuery : this.query;
-        var resultIsDifferent = dataMasking || documentInfo.hasNonreactiveDirective ?
+        const documentInfo = this.queryManager.getDocumentInfo(this.query);
+        const dataMasking = this.queryManager.dataMasking;
+        const query = dataMasking ? documentInfo.nonReactiveQuery : this.query;
+        const resultIsDifferent = dataMasking || documentInfo.hasNonreactiveDirective ?
             !equalByQuery(query, this.last.result, newResult, this.variables)
             : !equal(this.last.result, newResult);
         return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));
-    };
-    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
-        var last = this.last;
+    }
+    getLast(key, variablesMustMatch) {
+        const last = this.last;
         if (last &&
             last[key] &&
             (!variablesMustMatch || equal(last.variables, this.variables))) {
             return last[key];
         }
-    };
-    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {
+    }
+    // TODO: Consider deprecating this function
+    getLastResult(variablesMustMatch) {
         return this.getLast("result", variablesMustMatch);
-    };
-    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {
+    }
+    // TODO: Consider deprecating this function
+    getLastError(variablesMustMatch) {
         return this.getLast("error", variablesMustMatch);
-    };
-    ObservableQuery.prototype.resetLastResults = function () {
+    }
+    // TODO: Consider deprecating this function
+    resetLastResults() {
         delete this.last;
+        // TODO: This will need to be removed when tearing down an ObservableQuery
+        // since the observable will terminate.
         this.isTornDown = false;
-    };
-    ObservableQuery.prototype.resetQueryStoreErrors = function () {
-        this.queryManager.resetErrors(this.queryId);
-    };
+    }
     /**
      * Update the variables of this observable query, and fetch the new results.
      * This method should be preferred over `setVariables` in most use cases.
@@ -252,54 +237,61 @@ var ObservableQuery = /** @class */ (function (_super) {
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    ObservableQuery.prototype.refetch = function (variables) {
-        var _a;
-        var reobserveOptions = {
+    refetch(variables) {
+        const reobserveOptions = {
             // Always disable polling for refetches.
             pollInterval: 0,
         };
         // Unless the provided fetchPolicy always consults the network
         // (no-cache, network-only, or cache-and-network), override it with
         // network-only to force the refetch for this fetchQuery call.
-        var fetchPolicy = this.options.fetchPolicy;
+        const { fetchPolicy } = this.options;
         if (fetchPolicy === "no-cache") {
             reobserveOptions.fetchPolicy = "no-cache";
         }
         else {
             reobserveOptions.fetchPolicy = "network-only";
         }
-        if (globalThis.__DEV__ !== false && variables && hasOwnProperty.call(variables, "variables")) {
-            var queryDef = getQueryDefinition(this.query);
-            var vars = queryDef.variableDefinitions;
-            if (!vars || !vars.some(function (v) { return v.variable.name.value === "variables"; })) {
-                globalThis.__DEV__ !== false && invariant.warn(
-                    21,
-                    variables,
-                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef
-                );
+        if (__DEV__ && variables && hasOwnProperty.call(variables, "variables")) {
+            const queryDef = getQueryDefinition(this.query);
+            const vars = queryDef.variableDefinitions;
+            if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
+                __DEV__ && invariant.warn(67, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !equal(this.options.variables, variables)) {
             // Update the existing options with new variables
-            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);
+            reobserveOptions.variables = this.options.variables = {
+                ...this.options.variables,
+                ...variables,
+            };
         }
         this.queryInfo.resetLastWrite();
         return this.reobserve(reobserveOptions, NetworkStatus.refetch);
-    };
+    }
     /**
      * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
      */
-    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {
-        var _this = this;
-        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (__assign(__assign(__assign(__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) })))), { 
+    fetchMore(fetchMoreOptions) {
+        const combinedOptions = {
+            ...(fetchMoreOptions.query ? fetchMoreOptions : ({
+                ...this.options,
+                query: this.options.query,
+                ...fetchMoreOptions,
+                variables: {
+                    ...this.options.variables,
+                    ...fetchMoreOptions.variables,
+                },
+            })),
             // The fetchMore request goes immediately to the network and does
             // not automatically write its result to the cache (hence no-cache
             // instead of network-only), because we allow the caller of
             // fetchMore to provide an updateQuery callback that determines how
             // the data gets written to the cache.
-            fetchPolicy: "no-cache" });
+            fetchPolicy: "no-cache",
+        };
         combinedOptions.query = this.transformDocument(combinedOptions.query);
-        var qid = this.queryManager.generateQueryId();
+        const qid = this.queryManager.generateQueryId();
         // If a temporary query is passed to `fetchMore`, we don't want to store
         // it as the last query result since it may be an optimized query for
         // pagination. We will however run the transforms on the original document
@@ -311,24 +303,23 @@ var ObservableQuery = /** @class */ (function (_super) {
                 : combinedOptions.query;
         // Simulate a loading result for the original query with
         // result.networkStatus === NetworkStatus.fetchMore.
-        var queryInfo = this.queryInfo;
-        var originalNetworkStatus = queryInfo.networkStatus;
-        queryInfo.networkStatus = NetworkStatus.fetchMore;
+        const originalNetworkStatus = this.networkStatus;
+        this.networkStatus = NetworkStatus.fetchMore;
         if (combinedOptions.notifyOnNetworkStatusChange) {
             this.observe();
         }
-        var updatedQuerySet = new Set();
-        var updateQuery = fetchMoreOptions === null || fetchMoreOptions === void 0 ? void 0 : fetchMoreOptions.updateQuery;
-        var isCached = this.options.fetchPolicy !== "no-cache";
+        const updatedQuerySet = new Set();
+        const updateQuery = fetchMoreOptions?.updateQuery;
+        const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 22);
+            invariant(updateQuery, 68);
         }
         return this.queryManager
             .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)
-            .then(function (fetchMoreResult) {
-            _this.queryManager.removeQuery(qid);
-            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {
-                queryInfo.networkStatus = originalNetworkStatus;
+            .then((fetchMoreResult) => {
+            this.queryManager.removeQuery(qid);
+            if (this.networkStatus === NetworkStatus.fetchMore) {
+                this.networkStatus = originalNetworkStatus;
             }
             if (isCached) {
                 // Performing this cache update inside a cache.batch transaction ensures
@@ -336,21 +327,19 @@ var ObservableQuery = /** @class */ (function (_super) {
                 // updates. Most watchers will be using the QueryInfo class, which
                 // responds to notifications by calling reobserveCacheFirst to deliver
                 // fetchMore cache results back to this ObservableQuery.
-                _this.queryManager.cache.batch({
-                    update: function (cache) {
-                        var updateQuery = fetchMoreOptions.updateQuery;
+                this.queryManager.cache.batch({
+                    update: (cache) => {
+                        const { updateQuery } = fetchMoreOptions;
                         if (updateQuery) {
                             cache.updateQuery({
-                                query: _this.query,
-                                variables: _this.variables,
+                                query: this.query,
+                                variables: this.variables,
                                 returnPartialData: true,
                                 optimistic: false,
-                            }, function (previous) {
-                                return updateQuery(previous, {
-                                    fetchMoreResult: fetchMoreResult.data,
-                                    variables: combinedOptions.variables,
-                                });
-                            });
+                            }, (previous) => updateQuery(previous, {
+                                fetchMoreResult: fetchMoreResult.data,
+                                variables: combinedOptions.variables,
+                            }));
                         }
                         else {
                             // If we're using a field policy instead of updateQuery, the only
@@ -365,7 +354,7 @@ var ObservableQuery = /** @class */ (function (_super) {
                             });
                         }
                     },
-                    onWatchUpdated: function (watch) {
+                    onWatchUpdated: (watch) => {
                         // Record the DocumentNode associated with any watched query whose
                         // data were updated by the cache writes above.
                         updatedQuerySet.add(watch.query);
@@ -387,26 +376,31 @@ var ObservableQuery = /** @class */ (function (_super) {
                 // adjustment to the types on `updateQuery` since that function
                 // expects that the first argument always contains previous result
                 // data, but not `undefined`.
-                var lastResult = _this.getLast("result");
-                var data = updateQuery(lastResult.data, {
+                const lastResult = this.getLast("result");
+                const data = updateQuery(lastResult.data, {
                     fetchMoreResult: fetchMoreResult.data,
                     variables: combinedOptions.variables,
                 });
-                _this.reportResult(__assign(__assign({}, lastResult), { networkStatus: originalNetworkStatus, loading: isNetworkRequestInFlight(originalNetworkStatus), data: data }), _this.variables);
+                this.reportResult({
+                    ...lastResult,
+                    networkStatus: originalNetworkStatus,
+                    loading: isNetworkRequestInFlight(originalNetworkStatus),
+                    data: data,
+                }, this.variables);
             }
-            return _this.maskResult(fetchMoreResult);
+            return this.maskResult(fetchMoreResult);
         })
-            .finally(function () {
+            .finally(() => {
             // In case the cache writes above did not generate a broadcast
             // notification (which would have been intercepted by onWatchUpdated),
             // likely because the written data were the same as what was already in
             // the cache, we still want fetchMore to deliver its final loading:false
             // result with the unchanged data.
-            if (isCached && !updatedQuerySet.has(_this.query)) {
-                reobserveCacheFirst(_this);
+            if (isCached && !updatedQuerySet.has(this.query)) {
+                reobserveCacheFirst(this);
             }
         });
-    };
+    }
     // XXX the subscription variables are separate from the query variables.
     // if you want to update subscription variables, right now you have to do that separately,
     // and you can only do it by stopping the subscription and then subscribing again with new variables.
@@ -415,45 +409,45 @@ var ObservableQuery = /** @class */ (function (_super) {
      *
      * This function returns _another_ function that you can call to terminate the subscription.
      */
-    ObservableQuery.prototype.subscribeToMore = function (options) {
-        var _this = this;
-        var subscription = this.queryManager
+    subscribeToMore(options) {
+        const subscription = this.queryManager
             .startGraphQLSubscription({
             query: options.document,
             variables: options.variables,
             context: options.context,
         })
             .subscribe({
-            next: function (subscriptionData) {
-                var updateQuery = options.updateQuery;
+            next: (subscriptionData) => {
+                const { updateQuery } = options;
                 if (updateQuery) {
-                    _this.updateQuery(function (previous, updateOptions) {
-                        return updateQuery(previous, __assign({ subscriptionData: subscriptionData }, updateOptions));
-                    });
+                    this.updateQuery((previous, updateOptions) => updateQuery(previous, {
+                        subscriptionData: subscriptionData,
+                        ...updateOptions,
+                    }));
                 }
             },
-            error: function (err) {
+            error: (err) => {
                 if (options.onError) {
                     options.onError(err);
                     return;
                 }
-                globalThis.__DEV__ !== false && invariant.error(23, err);
+                __DEV__ && invariant.error(69, err);
             },
         });
         this.subscriptions.add(subscription);
-        return function () {
-            if (_this.subscriptions.delete(subscription)) {
+        return () => {
+            if (this.subscriptions.delete(subscription)) {
                 subscription.unsubscribe();
             }
         };
-    };
-    ObservableQuery.prototype.setOptions = function (newOptions) {
+    }
+    setOptions(newOptions) {
         return this.reobserve(newOptions);
-    };
-    ObservableQuery.prototype.silentSetOptions = function (newOptions) {
-        var mergedOptions = compact(this.options, newOptions || {});
+    }
+    silentSetOptions(newOptions) {
+        const mergedOptions = compact(this.options, newOptions || {});
         assign(this.options, mergedOptions);
-    };
+    }
     /**
      * Update the variables of this observable query, and fetch the new results
      * if they've changed. Most users should prefer `refetch` instead of
@@ -466,44 +460,44 @@ var ObservableQuery = /** @class */ (function (_super) {
      * Note: the promise will return the old results immediately if the variables
      * have not changed.
      *
-     * Note: the promise will return null immediately if the query is not active
+     * Note: the promise will return the last result immediately if the query is not active
      * (there are no subscribers).
      *
      * @param variables - The new set of variables. If there are missing variables,
      * the previous values of those variables will be used.
      */
-    ObservableQuery.prototype.setVariables = function (variables) {
+    async setVariables(variables) {
         if (equal(this.variables, variables)) {
             // If we have no observers, then we don't actually want to make a network
             // request. As soon as someone observes the query, the request will kick
             // off. For now, we just store any changes. (See #1077)
-            return this.observers.size ? this.result() : Promise.resolve();
+            return this.subject.getValue();
         }
         this.options.variables = variables;
         // See comment above
-        if (!this.observers.size) {
-            return Promise.resolve();
+        if (!this.hasObservers()) {
+            return this.subject.getValue();
         }
         return this.reobserve({
             // Reset options.fetchPolicy to its original value.
             fetchPolicy: this.options.initialFetchPolicy,
-            variables: variables,
+            variables,
         }, NetworkStatus.setVariables);
-    };
+    }
     /**
      * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
      *
      * See [using updateQuery and updateFragment](https://www.apollographql.com/docs/react/caching/cache-interaction/#using-updatequery-and-updatefragment) for additional information.
      */
-    ObservableQuery.prototype.updateQuery = function (mapFn) {
-        var queryManager = this.queryManager;
-        var _a = queryManager.cache.diff({
+    updateQuery(mapFn) {
+        const { queryManager } = this;
+        const { result, complete } = queryManager.cache.diff({
             query: this.options.query,
             variables: this.variables,
             returnPartialData: true,
             optimistic: false,
-        }), result = _a.result, complete = _a.complete;
-        var newResult = mapFn(result, {
+        });
+        const newResult = mapFn(result, {
             variables: this.variables,
             complete: !!complete,
             previousData: result,
@@ -516,30 +510,30 @@ var ObservableQuery = /** @class */ (function (_super) {
             });
             queryManager.broadcastQueries();
         }
-    };
+    }
     /**
      * A function that instructs the query to begin re-executing at a specified interval (in milliseconds).
      */
-    ObservableQuery.prototype.startPolling = function (pollInterval) {
+    startPolling(pollInterval) {
         this.options.pollInterval = pollInterval;
         this.updatePolling();
-    };
+    }
     /**
      * A function that instructs the query to stop polling after a previous call to `startPolling`.
      */
-    ObservableQuery.prototype.stopPolling = function () {
+    stopPolling() {
         this.options.pollInterval = 0;
         this.updatePolling();
-    };
+    }
     // Update options.fetchPolicy according to options.nextFetchPolicy.
-    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, 
+    applyNextFetchPolicy(reason, 
     // It's possible to use this method to apply options.nextFetchPolicy to
     // options.fetchPolicy even if options !== this.options, though that happens
     // most often when the options are temporary, used for only one request and
     // then thrown away, so nextFetchPolicy may not end up mattering.
     options) {
         if (options.nextFetchPolicy) {
-            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;
+            const { fetchPolicy = "cache-first", initialFetchPolicy = fetchPolicy } = options;
             if (fetchPolicy === "standby") {
                 // Do nothing, leaving options.fetchPolicy unchanged.
             }
@@ -555,10 +549,10 @@ var ObservableQuery = /** @class */ (function (_super) {
                 // update options.fetchPolicy after the initial network request, without
                 // having to call observableQuery.setOptions.
                 options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
-                    reason: reason,
-                    options: options,
+                    reason,
+                    options,
                     observable: this,
-                    initialFetchPolicy: initialFetchPolicy,
+                    initialFetchPolicy,
                 });
             }
             else if (reason === "variables-changed") {
@@ -569,21 +563,20 @@ var ObservableQuery = /** @class */ (function (_super) {
             }
         }
         return options.fetchPolicy;
-    };
-    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {
+    }
+    fetch(options, newNetworkStatus, emitLoadingState, query) {
         // TODO Make sure we update the networkStatus (and infer fetchVariables)
         // before actually committing to the fetch.
         this.queryManager.setObservableQuery(this);
-        return this.queryManager["fetchConcastWithInfo"](this.queryId, options, newNetworkStatus, query);
-    };
+        return this.queryManager.fetchObservableWithInfo(this.queryId, options, newNetworkStatus, query, emitLoadingState);
+    }
     // Turns polling on or off based on this.options.pollInterval.
-    ObservableQuery.prototype.updatePolling = function () {
-        var _this = this;
+    updatePolling() {
         // Avoid polling in SSR mode
         if (this.queryManager.ssrMode) {
             return;
         }
-        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;
+        const { pollingInfo, options: { pollInterval }, } = this;
         if (!pollInterval || !this.hasObservers()) {
             if (pollingInfo) {
                 clearTimeout(pollingInfo.timeout);
@@ -594,20 +587,19 @@ var ObservableQuery = /** @class */ (function (_super) {
         if (pollingInfo && pollingInfo.interval === pollInterval) {
             return;
         }
-        invariant(pollInterval, 24);
-        var info = pollingInfo || (this.pollingInfo = {});
+        invariant(pollInterval, 70);
+        const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
-        var maybeFetch = function () {
-            var _a, _b;
-            if (_this.pollingInfo) {
-                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&
-                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {
-                    _this.reobserve({
+        const maybeFetch = () => {
+            if (this.pollingInfo) {
+                if (!isNetworkRequestInFlight(this.networkStatus) &&
+                    !this.options.skipPollAttempt?.()) {
+                    this.reobserve({
                         // Most fetchPolicy options don't make sense to use in a polling context, as
                         // users wouldn't want to be polling the cache directly. However, network-only and
                         // no-cache are both useful for when the user wants to control whether or not the
                         // polled results are written to the cache.
-                        fetchPolicy: _this.options.initialFetchPolicy === "no-cache" ?
+                        fetchPolicy: this.options.initialFetchPolicy === "no-cache" ?
                             "no-cache"
                             : "network-only",
                     }, NetworkStatus.poll).then(poll, poll);
@@ -617,46 +609,50 @@ var ObservableQuery = /** @class */ (function (_super) {
                 }
             }
         };
-        var poll = function () {
-            var info = _this.pollingInfo;
+        const poll = () => {
+            const info = this.pollingInfo;
             if (info) {
                 clearTimeout(info.timeout);
                 info.timeout = setTimeout(maybeFetch, info.interval);
             }
         };
         poll();
-    };
-    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
-        if (variables === void 0) { variables = this.variables; }
-        var error = this.getLastError();
+    }
+    updateLastResult(newResult, variables = this.variables) {
+        let error = this.getLastError();
         // Preserve this.last.error unless the variables have changed.
         if (error && this.last && !equal(variables, this.last.variables)) {
             error = void 0;
         }
-        return (this.last = __assign({ result: this.queryManager.assumeImmutableResults ?
+        return (this.last = {
+            result: this.queryManager.assumeImmutableResults ?
                 newResult
-                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));
-    };
-    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
-        var _this = this;
+                : cloneDeep(newResult),
+            variables,
+            ...(error ? { error } : null),
+        });
+    }
+    // TODO: catch `EmptyError` and rethrow as network error if `complete`
+    // notification is emitted without a value.
+    reobserve(newOptions, newNetworkStatus) {
         this.isTornDown = false;
-        var useDisposableConcast = 
-        // Refetching uses a disposable Concast to allow refetches using different
+        const useDisposableObservable = 
+        // Refetching uses a disposable Observable to allow refetches using different
         // options/variables, without permanently altering the options of the
         // original ObservableQuery.
         newNetworkStatus === NetworkStatus.refetch ||
             // The fetchMore method does not actually call the reobserve method, but,
-            // if it did, it would definitely use a disposable Concast.
+            // if it did, it would definitely use a disposable Observable.
             newNetworkStatus === NetworkStatus.fetchMore ||
-            // Polling uses a disposable Concast so the polling options (which force
+            // Polling uses a disposable Observable so the polling options (which force
             // fetchPolicy to be "network-only" or "no-cache") won't override the original options.
             newNetworkStatus === NetworkStatus.poll;
         // Save the old variables, since Object.assign may modify them below.
-        var oldVariables = this.options.variables;
-        var oldFetchPolicy = this.options.fetchPolicy;
-        var mergedOptions = compact(this.options, newOptions || {});
-        var options = useDisposableConcast ?
-            // Disposable Concast fetches receive a shallow copy of this.options
+        const oldVariables = this.options.variables;
+        const oldFetchPolicy = this.options.fetchPolicy;
+        const mergedOptions = compact(this.options, newOptions || {});
+        const options = useDisposableObservable ?
+            // Disposable Observable fetches receive a shallow copy of this.options
             // (merged with newOptions), leaving this.options unmodified.
             mergedOptions
             : assign(this.options, mergedOptions);
@@ -664,9 +660,9 @@ var ObservableQuery = /** @class */ (function (_super) {
         // overwriting this.options.query when we aren't using a disposable concast.
         // We want to ensure we can re-run the custom document transforms the next
         // time a request is made against the original query.
-        var query = this.transformDocument(options.query);
+        const query = this.transformDocument(options.query);
         this.lastQuery = query;
-        if (!useDisposableConcast) {
+        if (!useDisposableObservable) {
             // We can skip calling updatePolling if we're not changing this.options.
             this.updatePolling();
             // Reset options.fetchPolicy to its original value when variables change,
@@ -688,133 +684,131 @@ var ObservableQuery = /** @class */ (function (_super) {
                 }
             }
         }
-        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));
-        var finishWaitingForOwnResult = function () {
-            if (_this.concast === concast) {
-                _this.waitForOwnResult = false;
+        const oldNetworkStatus = this.networkStatus;
+        if (!newNetworkStatus) {
+            newNetworkStatus = NetworkStatus.loading;
+            if (oldNetworkStatus !== NetworkStatus.loading &&
+                newOptions?.variables &&
+                !equal(newOptions.variables, oldVariables)) {
+                newNetworkStatus = NetworkStatus.setVariables;
+            }
+        }
+        this.networkStatus = newNetworkStatus;
+        this.waitForOwnResult &&= skipCacheDataFor(options.fetchPolicy);
+        const finishWaitingForOwnResult = () => {
+            if (this.linkObservable === observable) {
+                this.waitForOwnResult = false;
             }
         };
-        var variables = options.variables && __assign({}, options.variables);
-        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;
-        var observer = {
-            next: function (result) {
-                if (equal(_this.variables, variables)) {
+        const variables = options.variables && { ...options.variables };
+        const { notifyOnNetworkStatusChange = false } = options;
+        const { observable, fromLink } = this.fetch(options, newNetworkStatus, notifyOnNetworkStatusChange &&
+            oldNetworkStatus !== newNetworkStatus &&
+            isNetworkRequestInFlight(newNetworkStatus), query);
+        const observer = {
+            next: (result) => {
+                if (equal(this.variables, variables)) {
                     finishWaitingForOwnResult();
-                    _this.reportResult(result, variables);
+                    this.reportResult(result, variables);
                 }
             },
-            error: function (error) {
-                if (equal(_this.variables, variables)) {
-                    // Coming from `getResultsFromLink`, `error` here should always be an `ApolloError`.
-                    // However, calling `concast.cancel` can inject another type of error, so we have to
-                    // wrap it again here.
-                    if (!isApolloError(error)) {
-                        error = new ApolloError({ networkError: error });
-                    }
+            error: (error) => {
+                if (equal(this.variables, variables)) {
                     finishWaitingForOwnResult();
-                    _this.reportError(error, variables);
+                    this.reportError(error, variables);
                 }
             },
         };
-        if (!useDisposableConcast && (fromLink || !this.concast)) {
-            // We use the {add,remove}Observer methods directly to avoid wrapping
-            // observer with an unnecessary SubscriptionObserver object.
-            if (this.concast && this.observer) {
-                this.concast.removeObserver(this.observer);
+        if (!useDisposableObservable && (fromLink || !this.linkSubscription)) {
+            if (this.linkSubscription) {
+                this.linkSubscription.unsubscribe();
             }
-            this.concast = concast;
-            this.observer = observer;
+            this.linkObservable = observable;
+            this.linkSubscription = observable.subscribe(observer);
         }
-        concast.addObserver(observer);
-        return concast;
-    };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
-        return preventUnhandledRejection(this.reobserveAsConcast(newOptions, newNetworkStatus).promise.then(this.maskResult));
-    };
-    ObservableQuery.prototype.resubscribeAfterError = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
+        else {
+            observable.subscribe(observer);
         }
-        // If `lastError` is set in the current when the subscription is re-created,
-        // the subscription will immediately receive the error, which will
-        // cause it to terminate again. To avoid this, we first clear
-        // the last error/result from the `observableQuery` before re-starting
-        // the subscription, and restore the last value afterwards so that the
-        // subscription has a chance to stay open.
-        var last = this.last;
-        this.resetLastResults();
-        var subscription = this.subscribe.apply(this, args);
-        this.last = last;
-        return subscription;
-    };
+        return preventUnhandledRejection(
+        // Note: lastValueFrom will create a separate subscription to the
+        // observable which means that terminating this ObservableQuery will not
+        // cancel the request from the link chain.
+        lastValueFrom(observable).then(this.maskResult));
+    }
     // (Re)deliver the current result to this.observers without applying fetch
     // policies or making network requests.
-    ObservableQuery.prototype.observe = function () {
+    observe() {
         this.reportResult(
         // Passing false is important so that this.getCurrentResult doesn't
         // save the fetchMore result as this.lastResult, causing it to be
         // ignored due to the this.isDifferentFromLastResult check in
         // this.reportResult.
         this.getCurrentFullResult(false), this.variables);
-    };
-    ObservableQuery.prototype.reportResult = function (result, variables) {
-        var lastError = this.getLastError();
-        var isDifferent = this.isDifferentFromLastResult(result, variables);
+    }
+    reportResult(result, variables) {
+        const lastError = this.getLastError();
+        const isDifferent = this.isDifferentFromLastResult(result, variables);
         // Update the last result even when isDifferentFromLastResult returns false,
         // because the query may be using the @nonreactive directive, and we want to
         // save the the latest version of any nonreactive subtrees (in case
         // getCurrentResult is called), even though we skip broadcasting changes.
-        if (lastError || !result.partial || this.options.returnPartialData) {
-            this.updateLastResult(result, variables);
-        }
+        this.updateLastResult(result, variables);
+        this.networkStatus = result.networkStatus;
         if (lastError || isDifferent) {
-            iterateObserversSafely(this.observers, "next", this.maskResult(result));
+            this.subject.next(this.maskResult(result));
         }
-    };
-    ObservableQuery.prototype.reportError = function (error, variables) {
+    }
+    reportError(error, variables) {
         // Since we don't get the current result on errors, only the error, we
         // must mirror the updates that occur in QueryStore.markQueryError here
-        var errorResult = __assign(__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });
+        const errorResult = {
+            data: undefined,
+            partial: true,
+            ...this.getLastResult(),
+            error,
+            networkStatus: NetworkStatus.error,
+            loading: false,
+        };
         this.updateLastResult(errorResult, variables);
-        iterateObserversSafely(this.observers, "error", (this.last.error = error));
-    };
-    ObservableQuery.prototype.hasObservers = function () {
-        return this.observers.size > 0;
-    };
-    ObservableQuery.prototype.tearDownQuery = function () {
+        this.networkStatus = NetworkStatus.error;
+        this.last.error = error;
+        this.subject.next(errorResult);
+    }
+    hasObservers() {
+        return this.subject.observed;
+    }
+    tearDownQuery() {
         if (this.isTornDown)
             return;
-        if (this.concast && this.observer) {
-            this.concast.removeObserver(this.observer);
-            delete this.concast;
-            delete this.observer;
+        if (this.linkObservable && this.linkSubscription) {
+            this.linkSubscription.unsubscribe();
+            delete this.linkObservable;
+            delete this.linkSubscription;
         }
         this.stopPolling();
         // stop all active GraphQL subscriptions
-        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
         this.subscriptions.clear();
         this.queryManager.stopQuery(this.queryId);
-        this.observers.clear();
         this.isTornDown = true;
-    };
-    ObservableQuery.prototype.transformDocument = function (document) {
+    }
+    transformDocument(document) {
         return this.queryManager.transform(document);
-    };
-    ObservableQuery.prototype.maskResult = function (result) {
-        return result && "data" in result ? __assign(__assign({}, result), { data: this.queryManager.maskOperation({
-                document: this.query,
-                data: result.data,
-                fetchPolicy: this.options.fetchPolicy,
-                id: this.queryId,
-            }) }) : result;
-    };
-    return ObservableQuery;
-}(Observable));
-export { ObservableQuery };
-// Necessary because the ObservableQuery constructor has a different
-// signature than the Observable constructor.
-fixObservableSubclass(ObservableQuery);
+    }
+    maskResult(result) {
+        return result && "data" in result ?
+            {
+                ...result,
+                data: this.queryManager.maskOperation({
+                    document: this.query,
+                    data: result.data,
+                    fetchPolicy: this.options.fetchPolicy,
+                    id: this.queryId,
+                }),
+            }
+            : result;
+    }
+}
 // Reobserve with fetchPolicy effectively set to "cache-first", triggering
 // delivery of any new data from the cache, possibly falling back to the network
 // if any cache data are missing. This allows _complete_ cache results to be
@@ -823,13 +817,13 @@ fixObservableSubclass(ObservableQuery);
 // this.options.fetchPolicy is any other policy ("cache-first", "cache-only",
 // "standby", or "no-cache"), we call this.reobserve() as usual.
 export function reobserveCacheFirst(obsQuery) {
-    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;
+    const { fetchPolicy, nextFetchPolicy } = obsQuery.options;
     if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
         return obsQuery.reobserve({
             fetchPolicy: "cache-first",
             // Use a temporary nextFetchPolicy function that replaces itself with the
             // previous nextFetchPolicy value and returns the original fetchPolicy.
-            nextFetchPolicy: function (currentFetchPolicy, context) {
+            nextFetchPolicy(currentFetchPolicy, context) {
                 // Replace this nextFetchPolicy function in the options object with the
                 // original this.options.nextFetchPolicy value.
                 this.nextFetchPolicy = nextFetchPolicy;
@@ -845,12 +839,9 @@ export function reobserveCacheFirst(obsQuery) {
     }
     return obsQuery.reobserve();
 }
-function defaultSubscriptionObserverErrorCallback(error) {
-    globalThis.__DEV__ !== false && invariant.error(25, error.message, error.stack);
-}
 export function logMissingFieldErrors(missing) {
-    if (globalThis.__DEV__ !== false && missing) {
-        globalThis.__DEV__ !== false && invariant.debug(26, missing);
+    if (__DEV__ && missing) {
+        __DEV__ && invariant.debug(71, missing);
     }
 }
 function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {
@@ -858,4 +849,4 @@ function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"`
         fetchPolicy === "no-cache" ||
         fetchPolicy === "standby");
 }
-//# sourceMappingURL=ObservableQuery.js.map
+//# sourceMappingURL=ObservableQuery.js.map