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

package/core/ApolloClient.js

@@ -1,47 +1,26 @@
-import { OperationTypeNode } from "graphql";
-import { map } from "rxjs";
-import { NotImplementedHandler } from "@apollo/client/incremental";
-import { execute } from "@apollo/client/link";
-import { __DEV__ } from "@apollo/client/utilities/environment";
-import { checkDocument, compact, getApolloClientMemoryInternals, mergeOptions, } from "@apollo/client/utilities/internal";
-import { invariant } from "@apollo/client/utilities/invariant";
+import { __assign } from "tslib";
+import { invariant, newInvariantError } from "../utilities/globals/index.js";
+import { ApolloLink, execute } from "../link/core/index.js";
 import { version } from "../version.js";
+import { HttpLink } from "../link/http/index.js";
 import { QueryManager } from "./QueryManager.js";
-let hasSuggestedDevtools = false;
+import { LocalState } from "./LocalState.js";
+var hasSuggestedDevtools = false;
+// Though mergeOptions now resides in @apollo/client/utilities, it was
+// previously declared and exported from this module, and then reexported from
+// @apollo/client/core. Since we need to preserve that API anyway, the easiest
+// solution is to reexport mergeOptions where it was previously declared (here).
+import { mergeOptions } from "../utilities/index.js";
+import { getApolloClientMemoryInternals } from "../utilities/caching/getMemoryInternals.js";
+import { warnRemovedOption } from "../utilities/deprecation/index.js";
+export { mergeOptions };
 /**
  * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
  * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,
  * receive results from the server and cache the results in a store. It also delivers updates
  * to GraphQL queries through `Observable` instances.
  */
-export class ApolloClient {
-    link;
-    cache;
-    /**
-     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`.
-     */
-    disableNetworkFetches;
-    set prioritizeCacheValues(value) {
-        this.queryManager.prioritizeCacheValues = value;
-    }
-    /**
-     * Whether to prioritize cache values over network results when `query` or `watchQuery` 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 created `ObservableQuery` long-term.
-     *
-     * This can e.g. be used to prioritize the cache during the first render after SSR.
-     */
-    get prioritizeCacheValues() {
-        return this.queryManager.prioritizeCacheValues;
-    }
-    version;
-    queryDeduplication;
-    defaultOptions;
-    devtoolsConfig;
-    queryManager;
-    devToolsHookCb;
-    resetStoreCallbacks = [];
-    clearStoreCallbacks = [];
+var ApolloClient = /** @class */ (function () {
     /**
      * Constructs an instance of `ApolloClient`.
      *
@@ -68,26 +47,48 @@ export class ApolloClient {
      * });
      * ```
      */
-    constructor(options) {
-        if (__DEV__) {
-            invariant(options.cache, 67);
-            invariant(options.link, 68);
+    function ApolloClient(options) {
+        var _this = this;
+        var _a, _b, _c;
+        this.resetStoreCallbacks = [];
+        this.clearStoreCallbacks = [];
+        if (!options.cache) {
+            throw newInvariantError(16);
         }
-        const { cache, documentTransform, ssrMode = false, ssrForceFetchDelay = 0, 
+        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _d = options.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = options.ssrForceFetchDelay, ssrForceFetchDelay = _e === void 0 ? 0 : _e, 
         // Expose the client instance as window.__APOLLO_CLIENT__ and call
         // onBroadcast in queryManager.broadcastQueries to enable browser
         // devtools, but disable them by default in production.
-        connectToDevTools, queryDeduplication = true, defaultOptions, defaultContext, assumeImmutableResults = cache.assumeImmutableResults, localState, devtools, dataMasking, link, incrementalHandler = new NotImplementedHandler(), } = options;
+        connectToDevTools = options.connectToDevTools, _f = options.queryDeduplication, queryDeduplication = _f === void 0 ? true : _f, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _g = options.assumeImmutableResults, assumeImmutableResults = _g === void 0 ? cache.assumeImmutableResults : _g, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwareness = options.clientAwareness, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools, dataMasking = options.dataMasking;
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options, "connectToDevTools", "ApolloClient", "Please use `devtools.enabled` instead.");
+            warnRemovedOption(options, "uri", "ApolloClient", "Please initialize an instance of `HttpLink` with `uri` instead.");
+            warnRemovedOption(options, "credentials", "ApolloClient", "Please initialize an instance of `HttpLink` with `credentials` instead.");
+            warnRemovedOption(options, "headers", "ApolloClient", "Please initialize an instance of `HttpLink` with `headers` instead.");
+            warnRemovedOption(options, "name", "ApolloClient", "Please use the `clientAwareness.name` option instead.");
+            warnRemovedOption(options, "version", "ApolloClient", "Please use the `clientAwareness.version` option instead.");
+            warnRemovedOption(options, "typeDefs", "ApolloClient");
+            if (!options.link) {
+                globalThis.__DEV__ !== false && invariant.warn(17);
+            }
+        }
+        var link = options.link;
+        if (!link) {
+            link =
+                uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();
+        }
         this.link = link;
         this.cache = cache;
+        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;
         this.queryDeduplication = queryDeduplication;
-        this.defaultOptions = defaultOptions || {};
-        this.devtoolsConfig = {
-            ...devtools,
-            enabled: devtools?.enabled ?? connectToDevTools,
-        };
+        this.defaultOptions = defaultOptions || Object.create(null);
+        this.typeDefs = typeDefs;
+        this.devtoolsConfig = __assign(__assign({}, devtools), { enabled: (_a = devtools === null || devtools === void 0 ? void 0 : devtools.enabled) !== null && _a !== void 0 ? _a : connectToDevTools });
         if (this.devtoolsConfig.enabled === undefined) {
-            this.devtoolsConfig.enabled = __DEV__;
+            this.devtoolsConfig.enabled = globalThis.__DEV__ !== false;
+        }
+        if (ssrForceFetchDelay) {
+            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);
         }
         this.watchQuery = this.watchQuery.bind(this);
         this.query = this.query.bind(this);
@@ -96,57 +97,84 @@ export class ApolloClient {
         this.resetStore = this.resetStore.bind(this);
         this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);
         this.version = version;
-        this.queryManager = new QueryManager({
+        this.localState = new LocalState({
+            cache: cache,
             client: this,
+            resolvers: resolvers,
+            fragmentMatcher: fragmentMatcher,
+        });
+        this.queryManager = new QueryManager({
+            cache: this.cache,
+            link: this.link,
             defaultOptions: this.defaultOptions,
-            defaultContext,
-            documentTransform,
-            queryDeduplication,
-            ssrMode,
+            defaultContext: defaultContext,
+            documentTransform: documentTransform,
+            queryDeduplication: queryDeduplication,
+            ssrMode: ssrMode,
             dataMasking: !!dataMasking,
-            clientOptions: options,
-            incrementalHandler,
-            assumeImmutableResults,
+            clientAwareness: {
+                name: (_b = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.name) !== null && _b !== void 0 ? _b : clientAwarenessName,
+                version: (_c = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.version) !== null && _c !== void 0 ? _c : clientAwarenessVersion,
+            },
+            localState: this.localState,
+            assumeImmutableResults: assumeImmutableResults,
             onBroadcast: this.devtoolsConfig.enabled ?
-                () => {
-                    if (this.devToolsHookCb) {
-                        this.devToolsHookCb();
+                function () {
+                    if (_this.devToolsHookCb) {
+                        _this.devToolsHookCb({
+                            action: {},
+                            state: {
+                                queries: _this.queryManager.getQueryStore(),
+                                mutations: _this.queryManager.mutationStore || {},
+                            },
+                            dataWithOptimisticResults: _this.cache.extract(true),
+                        });
                     }
                 }
                 : void 0,
-            localState,
         });
-        this.prioritizeCacheValues = ssrMode || ssrForceFetchDelay > 0;
-        if (ssrForceFetchDelay) {
-            setTimeout(() => {
-                this.prioritizeCacheValues = false;
-            }, ssrForceFetchDelay);
-        }
         if (this.devtoolsConfig.enabled)
             this.connectToDevTools();
     }
-    connectToDevTools() {
+    Object.defineProperty(ApolloClient.prototype, "prioritizeCacheValues", {
+        /**
+         * Whether to prioritize cache values over network results when `query` or `watchQuery` 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 created `ObservableQuery` long-term.
+         *
+         * This can e.g. be used to prioritize the cache during the first render after SSR.
+         */
+        get: function () {
+            return this.disableNetworkFetches;
+        },
+        set: function (value) {
+            this.disableNetworkFetches = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ApolloClient.prototype.connectToDevTools = function () {
         if (typeof window === "undefined") {
             return;
         }
-        const windowWithDevTools = window;
-        const devtoolsSymbol = Symbol.for("apollo.devtools");
+        var windowWithDevTools = window;
+        var devtoolsSymbol = Symbol.for("apollo.devtools");
         (windowWithDevTools[devtoolsSymbol] =
             windowWithDevTools[devtoolsSymbol] || []).push(this);
         windowWithDevTools.__APOLLO_CLIENT__ = this;
         /**
          * Suggest installing the devtools for developers who don't have them
          */
-        if (!hasSuggestedDevtools && __DEV__) {
+        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {
             hasSuggestedDevtools = true;
             if (window.document &&
                 window.top === window.self &&
                 /^(https?|file):$/.test(window.location.protocol)) {
-                setTimeout(() => {
+                setTimeout(function () {
                     if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {
-                        const nav = window.navigator;
-                        const ua = nav && nav.userAgent;
-                        let url;
+                        var nav = window.navigator;
+                        var ua = nav && nav.userAgent;
+                        var url = void 0;
                         if (typeof ua === "string") {
                             if (ua.indexOf("Chrome/") > -1) {
                                 url =
@@ -159,39 +187,33 @@ export class ApolloClient {
                             }
                         }
                         if (url) {
-                            __DEV__ && invariant.log("Download the Apollo DevTools for a better development " +
+                            globalThis.__DEV__ !== false && invariant.log("Download the Apollo DevTools for a better development " +
                                 "experience: %s", url);
                         }
                     }
                 }, 10000);
             }
         }
-    }
-    /**
-     * The `DocumentTransform` used to modify GraphQL documents before a request
-     * is made. If a custom `DocumentTransform` is not provided, this will be the
-     * default document transform.
-     */
-    get documentTransform() {
-        return this.queryManager.documentTransform;
-    }
-    /**
-     * The configured `LocalState` instance used to enable the use of `@client`
-     * fields.
-     */
-    get localState() {
-        return this.queryManager.localState;
-    }
-    set localState(localState) {
-        this.queryManager.localState = localState;
-    }
+    };
+    Object.defineProperty(ApolloClient.prototype, "documentTransform", {
+        /**
+         * The `DocumentTransform` used to modify GraphQL documents before a request
+         * is made. If a custom `DocumentTransform` is not provided, this will be the
+         * default document transform.
+         */
+        get: function () {
+            return this.queryManager.documentTransform;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Call this method to terminate any active client processes, making it safe
      * to dispose of this `ApolloClient` instance.
      */
-    stop() {
+    ApolloClient.prototype.stop = function () {
         this.queryManager.stop();
-    }
+    };
     /**
      * This watches the cache store of the query according to the options specified and
      * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and
@@ -211,12 +233,22 @@ export class ApolloClient {
      * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
      * a description of store reactivity.
      */
-    watchQuery(options) {
+    ApolloClient.prototype.watchQuery = function (options) {
         if (this.defaultOptions.watchQuery) {
             options = mergeOptions(this.defaultOptions.watchQuery, options);
         }
+        // XXX Overwriting options is probably not the best way to do this long term...
+        if (this.disableNetworkFetches &&
+            (options.fetchPolicy === "network-only" ||
+                options.fetchPolicy === "cache-and-network")) {
+            options = __assign(__assign({}, options), { fetchPolicy: "cache-first" });
+        }
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options, "canonizeResults", "client.watchQuery");
+            warnRemovedOption(options, "partialRefetch", "client.watchQuery");
+        }
         return this.queryManager.watchQuery(options);
-    }
+    };
     /**
      * This resolves a single query according to the options specified and
      * returns a `Promise` which is either resolved with the resulting data
@@ -226,21 +258,23 @@ export class ApolloClient {
      * describe how this query should be treated e.g. whether it should hit the
      * server at all or just resolve from the cache, etc.
      */
-    query(options) {
+    ApolloClient.prototype.query = function (options) {
         if (this.defaultOptions.query) {
             options = mergeOptions(this.defaultOptions.query, options);
         }
-        if (__DEV__) {
-            invariant(options.fetchPolicy !== "cache-and-network", 69);
-            invariant(options.fetchPolicy !== "standby", 70);
-            invariant(options.query, 71);
-            invariant(options.query.kind === "Document", 72);
-            invariant(!options.returnPartialData, 73);
-            invariant(!options.pollInterval, 74);
-            invariant(!options.notifyOnNetworkStatusChange, 75);
+        invariant(options.fetchPolicy !== "cache-and-network", 18);
+        if (this.disableNetworkFetches && options.fetchPolicy === "network-only") {
+            options = __assign(__assign({}, options), { fetchPolicy: "cache-first" });
+        }
+        if (globalThis.__DEV__ !== false) {
+            warnRemovedOption(options, "canonizeResults", "client.query");
+            warnRemovedOption(options, "notifyOnNetworkStatusChange", "client.query", "This option does not affect `client.query` and can be safely removed.");
+            if (options.fetchPolicy === "standby") {
+                globalThis.__DEV__ !== false && invariant.warn(19);
+            }
         }
         return this.queryManager.query(options);
-    }
+    };
     /**
      * This resolves a single mutation according to the options specified and returns a
      * Promise which is either resolved with the resulting data or rejected with an
@@ -249,37 +283,28 @@ export class ApolloClient {
      *
      * It takes options as an object with the following keys and values:
      */
-    mutate(options) {
-        const optionsWithDefaults = mergeOptions(compact({
-            fetchPolicy: "network-only",
-            errorPolicy: "none",
-        }, this.defaultOptions.mutate), options);
-        if (__DEV__) {
-            invariant(optionsWithDefaults.mutation, 76);
-            invariant(optionsWithDefaults.fetchPolicy === "network-only" ||
-                optionsWithDefaults.fetchPolicy === "no-cache", 77);
+    ApolloClient.prototype.mutate = function (options) {
+        if (this.defaultOptions.mutate) {
+            options = mergeOptions(this.defaultOptions.mutate, options);
         }
-        checkDocument(optionsWithDefaults.mutation, OperationTypeNode.MUTATION);
-        return this.queryManager.mutate(optionsWithDefaults);
-    }
+        return this.queryManager.mutate(options);
+    };
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.
      */
-    subscribe(options) {
-        const cause = {};
-        const observable = this.queryManager.startGraphQLSubscription(options);
-        const mapped = observable.pipe(map((result) => ({
-            ...result,
-            data: this.queryManager.maskOperation({
+    ApolloClient.prototype.subscribe = function (options) {
+        var _this = this;
+        var id = this.queryManager.generateQueryId();
+        return this.queryManager
+            .startGraphQLSubscription(options)
+            .map(function (result) { return (__assign(__assign({}, result), { data: _this.queryManager.maskOperation({
                 document: options.query,
                 data: result.data,
                 fetchPolicy: options.fetchPolicy,
-                cause,
-            }),
-        })));
-        return Object.assign(mapped, { restart: observable.restart });
-    }
+                id: id,
+            }) })); });
+    };
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL query without making a network request. This method will start at
@@ -289,9 +314,10 @@ export class ApolloClient {
      * @param optimistic - Set to `true` to allow `readQuery` to return
      * optimistic results. Is `false` by default.
      */
-    readQuery(options, optimistic = false) {
+    ApolloClient.prototype.readQuery = function (options, optimistic) {
+        if (optimistic === void 0) { optimistic = false; }
         return this.cache.readQuery(options, optimistic);
-    }
+    };
     /**
      * Watches the cache store of the fragment according to the options specified
      * and returns an `Observable`. We can subscribe to this
@@ -308,12 +334,10 @@ export class ApolloClient {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment(options) {
-        return this.cache.watchFragment({
-            ...options,
-            [Symbol.for("apollo.dataMasking")]: this.queryManager.dataMasking,
-        });
-    }
+    ApolloClient.prototype.watchFragment = function (options) {
+        var _a;
+        return this.cache.watchFragment(__assign(__assign({}, options), (_a = {}, _a[Symbol.for("apollo.dataMasking")] = this.queryManager.dataMasking, _a)));
+    };
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL fragment without making a network request. This method will read a
@@ -328,21 +352,22 @@ export class ApolloClient {
      * @param optimistic - Set to `true` to allow `readFragment` to return
      * optimistic results. Is `false` by default.
      */
-    readFragment(options, optimistic = false) {
+    ApolloClient.prototype.readFragment = function (options, optimistic) {
+        if (optimistic === void 0) { optimistic = false; }
         return this.cache.readFragment(options, optimistic);
-    }
+    };
     /**
      * Writes some data in the shape of the provided GraphQL query directly to
      * the store. This method will start at the root query. To start at a
      * specific id returned by `dataIdFromObject` then use `writeFragment`.
      */
-    writeQuery(options) {
-        const ref = this.cache.writeQuery(options);
+    ApolloClient.prototype.writeQuery = function (options) {
+        var ref = this.cache.writeQuery(options);
         if (options.broadcast !== false) {
             this.queryManager.broadcastQueries();
         }
         return ref;
-    }
+    };
     /**
      * Writes some data in the shape of the provided GraphQL fragment directly to
      * the store. This method will write to a GraphQL fragment from any arbitrary
@@ -354,19 +379,19 @@ export class ApolloClient {
      * in a document with multiple fragments then you must also specify a
      * `fragmentName`.
      */
-    writeFragment(options) {
-        const ref = this.cache.writeFragment(options);
+    ApolloClient.prototype.writeFragment = function (options) {
+        var ref = this.cache.writeFragment(options);
         if (options.broadcast !== false) {
             this.queryManager.broadcastQueries();
         }
         return ref;
-    }
-    __actionHookForDevTools(cb) {
+    };
+    ApolloClient.prototype.__actionHookForDevTools = function (cb) {
         this.devToolsHookCb = cb;
-    }
-    __requestRaw(payload) {
-        return execute(this.link, payload, { client: this });
-    }
+    };
+    ApolloClient.prototype.__requestRaw = function (payload) {
+        return execute(this.link, payload);
+    };
     /**
      * Resets your entire store by clearing out your cache and then re-executing
      * all of your active queries. This makes it so that you may guarantee that
@@ -383,47 +408,55 @@ export class ApolloClient {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    resetStore() {
+    ApolloClient.prototype.resetStore = function () {
+        var _this = this;
         return Promise.resolve()
-            .then(() => this.queryManager.clearStore({
-            discardWatches: false,
-        }))
-            .then(() => Promise.all(this.resetStoreCallbacks.map((fn) => fn())))
-            .then(() => this.reFetchObservableQueries());
-    }
+            .then(function () {
+            return _this.queryManager.clearStore({
+                discardWatches: false,
+            });
+        })
+            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })
+            .then(function () { return _this.reFetchObservableQueries(); });
+    };
     /**
      * Remove all data from the store. Unlike `resetStore`, `clearStore` will
      * not refetch any active queries.
      */
-    clearStore() {
+    ApolloClient.prototype.clearStore = function () {
+        var _this = this;
         return Promise.resolve()
-            .then(() => this.queryManager.clearStore({
-            discardWatches: true,
-        }))
-            .then(() => Promise.all(this.clearStoreCallbacks.map((fn) => fn())));
-    }
+            .then(function () {
+            return _this.queryManager.clearStore({
+                discardWatches: true,
+            });
+        })
+            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });
+    };
     /**
      * Allows callbacks to be registered that are executed when the store is
      * reset. `onResetStore` returns an unsubscribe function that can be used
      * to remove registered callbacks.
      */
-    onResetStore(cb) {
+    ApolloClient.prototype.onResetStore = function (cb) {
+        var _this = this;
         this.resetStoreCallbacks.push(cb);
-        return () => {
-            this.resetStoreCallbacks = this.resetStoreCallbacks.filter((c) => c !== cb);
+        return function () {
+            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });
         };
-    }
+    };
     /**
      * Allows callbacks to be registered that are executed when the store is
      * cleared. `onClearStore` returns an unsubscribe function that can be used
      * to remove registered callbacks.
      */
-    onClearStore(cb) {
+    ApolloClient.prototype.onClearStore = function (cb) {
+        var _this = this;
         this.clearStoreCallbacks.push(cb);
-        return () => {
-            this.clearStoreCallbacks = this.clearStoreCallbacks.filter((c) => c !== cb);
+        return function () {
+            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });
         };
-    }
+    };
     /**
      * Refetches all of your active queries.
      *
@@ -436,9 +469,9 @@ export class ApolloClient {
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
      */
-    reFetchObservableQueries(includeStandby) {
-        return this.queryManager.refetchObservableQueries(includeStandby);
-    }
+    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {
+        return this.queryManager.reFetchObservableQueries(includeStandby);
+    };
     /**
      * Refetches specified active queries. Similar to "reFetchObservableQueries()" but with a specific list of queries.
      *
@@ -450,15 +483,15 @@ export class ApolloClient {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    refetchQueries(options) {
-        const map = this.queryManager.refetchQueries(options);
-        const queries = [];
-        const results = [];
-        map.forEach((result, obsQuery) => {
+    ApolloClient.prototype.refetchQueries = function (options) {
+        var map = this.queryManager.refetchQueries(options);
+        var queries = [];
+        var results = [];
+        map.forEach(function (result, obsQuery) {
             queries.push(obsQuery);
             results.push(result);
         });
-        const result = Promise.all(results);
+        var result = Promise.all(results);
         // In case you need the raw results immediately, without awaiting
         // Promise.all(results):
         result.queries = queries;
@@ -466,11 +499,11 @@ export class ApolloClient {
         // If you decide to ignore the result Promise because you're using
         // result.queries and result.results instead, you shouldn't have to worry
         // about preventing uncaught rejections for the Promise.all result.
-        result.catch((error) => {
-            __DEV__ && invariant.debug(78, error);
+        result.catch(function (error) {
+            globalThis.__DEV__ !== false && invariant.debug(20, error);
         });
         return result;
-    }
+    };
     /**
      * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
      * query ID strings.
@@ -482,15 +515,16 @@ export class ApolloClient {
      * by passing "all" instead of "active", or you can include just a subset of
      * active queries by passing an array of query names or DocumentNode objects.
      */
-    getObservableQueries(include = "active") {
+    ApolloClient.prototype.getObservableQueries = function (include) {
+        if (include === void 0) { include = "active"; }
         return this.queryManager.getObservableQueries(include);
-    }
+    };
     /**
      * Exposes the cache's complete state, in a serializable format for later restoration.
      */
-    extract(optimistic) {
+    ApolloClient.prototype.extract = function (optimistic) {
         return this.cache.extract(optimistic);
-    }
+    };
     /**
      * Replaces existing state in the cache (if any) with the values expressed by
      * `serializedState`.
@@ -498,99 +532,100 @@ export class ApolloClient {
      * Called when hydrating a cache (server side rendering, or offline storage),
      * and also (potentially) during hot reloads.
      */
-    restore(serializedState) {
+    ApolloClient.prototype.restore = function (serializedState) {
         return this.cache.restore(serializedState);
-    }
+    };
     /**
-     * Define a new ApolloLink (or link chain) that Apollo Client will use.
+     * Add additional local resolvers.
+     *
+     * @deprecated `addResolvers` will been removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * Use `client.localState.addResolvers(resolvers)`. Alternatively, store
+     * the `LocalState` instance in a separate variable and call `addResolvers` on
+     * that.
      */
-    setLink(newLink) {
-        this.link = newLink;
-    }
-    get defaultContext() {
-        return this.queryManager.defaultContext;
-    }
+    ApolloClient.prototype.addResolvers = function (resolvers) {
+        this.localState.addResolvers(resolvers);
+    };
     /**
-     * @experimental
-     * This is not a stable API - it is used in development builds to expose
-     * information to the DevTools.
-     * Use at your own risk!
-     * For more details, see [Memory Management](https://www.apollographql.com/docs/react/caching/memory-management/#measuring-cache-usage)
+     * Set (override existing) local resolvers.
      *
-     * @example
-     * ```ts
-     * console.log(client.getMemoryInternals())
-     * ```
-     * Logs output in the following JSON format:
-     * @example
-     * ```json
-     *{
-     *  limits:     {
-     *    canonicalStringify: 1000,
-     *    print: 2000,
-     *    'documentTransform.cache': 2000,
-     *    'queryManager.getDocumentInfo': 2000,
-     *    'PersistedQueryLink.persistedQueryHashes': 2000,
-     *    'fragmentRegistry.transform': 2000,
-     *    'fragmentRegistry.lookup': 1000,
-     *    'fragmentRegistry.findFragmentSpreads': 4000,
-     *    'cache.fragmentQueryDocuments': 1000,
-     *    'removeTypenameFromVariables.getVariableDefinitions': 2000,
-     *    'inMemoryCache.maybeBroadcastWatch': 5000,
-     *    'inMemoryCache.executeSelectionSet': 10000,
-     *    'inMemoryCache.executeSubSelectedArray': 5000
-     *  },
-     *  sizes: {
-     *    canonicalStringify: 4,
-     *    print: 14,
-     *    addTypenameDocumentTransform: [
-     *      {
-     *        cache: 14,
-     *      },
-     *    ],
-     *    queryManager: {
-     *      getDocumentInfo: 14,
-     *      documentTransforms: [
-     *        {
-     *          cache: 14,
-     *        },
-     *        {
-     *          cache: 14,
-     *        },
-     *      ],
-     *    },
-     *    fragmentRegistry: {
-     *      findFragmentSpreads: 34,
-     *      lookup: 20,
-     *      transform: 14,
-     *    },
-     *    cache: {
-     *      fragmentQueryDocuments: 22,
-     *    },
-     *    inMemoryCache: {
-     *      executeSelectionSet: 4345,
-     *      executeSubSelectedArray: 1206,
-     *      maybeBroadcastWatch: 32,
-     *    },
-     *    links: [
-     *      {
-     *        PersistedQueryLink: {
-     *          persistedQueryHashes: 14,
-     *        },
-     *      },
-     *      {
-     *        removeTypenameFromVariables: {
-     *          getVariableDefinitions: 14,
-     *        },
-     *      },
-     *    ],
-     *  },
-     * }
-     *```
+     * @deprecated `setResolvers` will been removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * If possible, stop using the `setResolvers` method.
+     *
+     * **When upgrading**
+     *
+     * Remove the use of `setResolvers`.
      */
-    getMemoryInternals;
-}
-if (__DEV__) {
+    ApolloClient.prototype.setResolvers = function (resolvers) {
+        this.localState.setResolvers(resolvers);
+    };
+    /**
+     * Get all registered local resolvers.
+     *
+     * @deprecated `getResolvers` will be removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * If possible, stop using the `getResolvers` method.
+     *
+     * **When upgrading**
+     *
+     * Remove the use of `getResolvers`.
+     */
+    ApolloClient.prototype.getResolvers = function () {
+        return this.localState.getResolvers();
+    };
+    /**
+     * Set a custom local state fragment matcher.
+     *
+     * @deprecated Custom fragment matchers will no longer be supported in Apollo
+     * Client 4.0 and has been replaced by `cache.fragmentMatches`. It is safe to
+     * continue using `setLocalStateFragmentMatcher` in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * Leverage `possibleTypes` with `InMemoryCache` to ensure fragments match
+     * correctly. Ensure `possibleTypes` include local types if needed. If working
+     * with a 3rd party cache implementation, ensure the 3rd party cache implements
+     * the `cache.fragmentMatches` method. This function should no longer be used.
+     */
+    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {
+        this.localState.setFragmentMatcher(fragmentMatcher);
+    };
+    /**
+     * Define a new ApolloLink (or link chain) that Apollo Client will use.
+     */
+    ApolloClient.prototype.setLink = function (newLink) {
+        this.link = this.queryManager.link = newLink;
+    };
+    Object.defineProperty(ApolloClient.prototype, "defaultContext", {
+        get: function () {
+            return this.queryManager.defaultContext;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ApolloClient;
+}());
+export { ApolloClient };
+if (globalThis.__DEV__ !== false) {
     ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;
 }
-//# sourceMappingURL=ApolloClient.js.map
+//# sourceMappingURL=ApolloClient.js.map