@apollo/client 3.6.2 → 3.6.5

package/react/hooks/useSyncExternalStore.js

@@ -0,0 +1,48 @@
+import { invariant } from "../../utilities/globals/index.js";
+import * as React from 'react';
+import { canUseLayoutEffect } from "../../utilities/index.js";
+var didWarnUncachedGetSnapshot = false;
+var uSESKey = "useSyncExternalStore";
+var realHook = React[uSESKey];
+export var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {
+    var value = getSnapshot();
+    if (__DEV__ &&
+        !didWarnUncachedGetSnapshot &&
+        value !== getSnapshot()) {
+        didWarnUncachedGetSnapshot = true;
+        __DEV__ && invariant.error('The result of getSnapshot should be cached to avoid an infinite loop');
+    }
+    var _a = React.useState({ inst: { value: value, getSnapshot: getSnapshot } }), inst = _a[0].inst, forceUpdate = _a[1];
+    if (canUseLayoutEffect) {
+        React.useLayoutEffect(function () {
+            Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+            if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({ inst: inst });
+            }
+        }, [subscribe, value, getSnapshot]);
+    }
+    else {
+        Object.assign(inst, { value: value, getSnapshot: getSnapshot });
+    }
+    React.useEffect(function () {
+        if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({ inst: inst });
+        }
+        return subscribe(function handleStoreChange() {
+            if (checkIfSnapshotChanged(inst)) {
+                forceUpdate({ inst: inst });
+            }
+        });
+    }, [subscribe]);
+    return value;
+});
+function checkIfSnapshotChanged(_a) {
+    var value = _a.value, getSnapshot = _a.getSnapshot;
+    try {
+        return value !== getSnapshot();
+    }
+    catch (_b) {
+        return true;
+    }
+}
+//# sourceMappingURL=useSyncExternalStore.js.map

package/react/hooks/useSyncExternalStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncExternalStore.js","sourceRoot":"","sources":["../../../src/react/hooks/useSyncExternalStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,IAAI,0BAA0B,GAAG,KAAK,CAAC;AAYvC,IAAM,OAAO,GAAG,sBAA4C,CAAC;AAC7D,IAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAmC,CAAC;AAMlE,MAAM,CAAC,IAAM,oBAAoB,GAAuB,QAAQ,IAAI,CAAC,UACnE,SAAS,EACT,WAAW,EACX,iBAAiB;IAMjB,IAAM,KAAK,GAAG,WAAW,EAAE,CAAC;IAC5B,IAEE,OAAO;QACP,CAAC,0BAA0B;QAG3B,KAAK,KAAK,WAAW,EAAE,EACvB;QACA,0BAA0B,GAAG,IAAI,CAAC;QAElC,SAAS,CAAC,KAAK,CACb,sEAAsE,CACvE,CAAC;KACH;IAgBK,IAAA,KAAwB,KAAK,CAAC,QAAQ,CAAC,EAAC,IAAI,EAAE,EAAC,KAAK,OAAA,EAAE,WAAW,aAAA,EAAC,EAAC,CAAC,EAAlE,IAAI,aAAA,EAAG,WAAW,QAAgD,CAAC;IAK3E,IAAI,kBAAkB,EAAE;QAKtB,KAAK,CAAC,eAAe,CAAC;YACpB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,KAAK,OAAA,EAAE,WAAW,aAAA,EAAE,CAAC,CAAC;YAK5C,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE;gBAEhC,WAAW,CAAC,EAAC,IAAI,MAAA,EAAC,CAAC,CAAC;aACrB;QACH,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;KACrC;SAAM;QACL,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,KAAK,OAAA,EAAE,WAAW,aAAA,EAAE,CAAC,CAAC;KAC7C;IAED,KAAK,CAAC,SAAS,CAAC;QAGd,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE;YAEhC,WAAW,CAAC,EAAC,IAAI,MAAA,EAAC,CAAC,CAAC;SACrB;QAGD,OAAO,SAAS,CAAC,SAAS,iBAAiB;YAQzC,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE;gBAEhC,WAAW,CAAC,EAAC,IAAI,MAAA,EAAC,CAAC,CAAC;aACrB;QACH,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAEhB,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,CAAC;AAEH,SAAS,sBAAsB,CAAW,EAMzC;QALC,KAAK,WAAA,EACL,WAAW,iBAAA;IAKX,IAAI;QACF,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;KAChC;IAAC,WAAM;QACN,OAAO,IAAI,CAAC;KACb;AACH,CAAC","sourcesContent":["import { invariant } from '../../utilities/globals';\nimport * as React from 'react';\n\nimport { canUseLayoutEffect } from '../../utilities';\n\nlet didWarnUncachedGetSnapshot = false;\n\ntype RealUseSESHookType =\n  // This import depends only on the @types/use-sync-external-store package, not\n  // the actual use-sync-external-store package, which is not installed. It\n  // might be nice to get this type from React 18, but it still needs to work\n  // when only React 17 or earlier is installed.\n  typeof import(\"use-sync-external-store\").useSyncExternalStore;\n\n// Prevent webpack from complaining about our feature detection of the\n// useSyncExternalStore property of the React namespace, which is expected not\n// to exist when using React 17 and earlier, and that's fine.\nconst uSESKey = \"useSyncExternalStore\" as keyof typeof React;\nconst realHook = React[uSESKey] as RealUseSESHookType | undefined;\n\n// Adapted from https://www.npmjs.com/package/use-sync-external-store, with\n// Apollo Client deviations called out by \"// DEVIATION ...\" comments.\n\n// When/if React.useSyncExternalStore is defined, delegate fully to it.\nexport const useSyncExternalStore: RealUseSESHookType = realHook || ((\n  subscribe,\n  getSnapshot,\n  getServerSnapshot,\n) => {\n  // Read the current snapshot from the store on every render. Again, this\n  // breaks the rules of React, and only works here because of specific\n  // implementation details, most importantly that updates are\n  // always synchronous.\n  const value = getSnapshot();\n  if (\n    // DEVIATION: Using our own __DEV__ polyfill (from ../../utilities/globals).\n    __DEV__ &&\n    !didWarnUncachedGetSnapshot &&\n    // DEVIATION: Not using Object.is because we know our snapshots will never\n    // be exotic primitive values like NaN, which is !== itself.\n    value !== getSnapshot()\n  ) {\n    didWarnUncachedGetSnapshot = true;\n    // DEVIATION: Using invariant.error instead of console.error directly.\n    invariant.error(\n      'The result of getSnapshot should be cached to avoid an infinite loop',\n    );\n  }\n\n  // Because updates are synchronous, we don't queue them. Instead we force a\n  // re-render whenever the subscribed state changes by updating an some\n  // arbitrary useState hook. Then, during render, we call getSnapshot to read\n  // the current value.\n  //\n  // Because we don't actually use the state returned by the useState hook, we\n  // can save a bit of memory by storing other stuff in that slot.\n  //\n  // To implement the early bailout, we need to track some things on a mutable\n  // object. Usually, we would put that in a useRef hook, but we can stash it in\n  // our useState hook instead.\n  //\n  // To force a re-render, we call forceUpdate({inst}). That works because the\n  // new object always fails an equality check.\n  const [{inst}, forceUpdate] = React.useState({inst: {value, getSnapshot}});\n\n  // Track the latest getSnapshot function with a ref. This needs to be updated\n  // in the layout phase so we can access it during the tearing check that\n  // happens on subscribe.\n  if (canUseLayoutEffect) {\n    // DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,\n    // which may seem like a conditional hook, but this code ends up behaving\n    // unconditionally (one way or the other) because canUseLayoutEffect is\n    // constant.\n    React.useLayoutEffect(() => {\n      Object.assign(inst, { value, getSnapshot });\n      // Whenever getSnapshot or subscribe changes, we need to check in the\n      // commit phase if there was an interleaved mutation. In concurrent mode\n      // this can happen all the time, but even in synchronous mode, an earlier\n      // effect may have mutated the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({inst});\n      }\n    }, [subscribe, value, getSnapshot]);\n  } else {\n    Object.assign(inst, { value, getSnapshot });\n  }\n\n  React.useEffect(() => {\n    // Check for changes right before subscribing. Subsequent changes will be\n    // detected in the subscription handler.\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({inst});\n    }\n\n    // Subscribe to the store and return a clean-up function.\n    return subscribe(function handleStoreChange() {\n      // TODO: Because there is no cross-renderer API for batching updates, it's\n      // up to the consumer of this library to wrap their subscription event\n      // with unstable_batchedUpdates. Should we try to detect when this isn't\n      // the case and print a warning in development?\n\n      // The store changed. Check if the snapshot changed since the last time we\n      // read from the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({inst});\n      }\n    });\n  }, [subscribe]);\n\n  return value;\n});\n\nfunction checkIfSnapshotChanged<Snapshot>({\n  value,\n  getSnapshot,\n}: {\n  value: Snapshot;\n  getSnapshot: () => Snapshot;\n}): boolean {\n  try {\n    return value !== getSnapshot();\n  } catch {\n    return true;\n  }\n}\n"]}

package/react/parser/parser.cjs.native.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+
+exports.DocumentType = void 0;
+(function (DocumentType) {
+    DocumentType[DocumentType["Query"] = 0] = "Query";
+    DocumentType[DocumentType["Mutation"] = 1] = "Mutation";
+    DocumentType[DocumentType["Subscription"] = 2] = "Subscription";
+})(exports.DocumentType || (exports.DocumentType = {}));
+var cache = new Map();
+function operationName(type) {
+    var name;
+    switch (type) {
+        case exports.DocumentType.Query:
+            name = 'Query';
+            break;
+        case exports.DocumentType.Mutation:
+            name = 'Mutation';
+            break;
+        case exports.DocumentType.Subscription:
+            name = 'Subscription';
+            break;
+    }
+    return name;
+}
+function parser(document) {
+    var cached = cache.get(document);
+    if (cached)
+        return cached;
+    var variables, type, name;
+    __DEV__ ? globals.invariant(!!document && !!document.kind, "Argument of ".concat(document, " passed to parser was not a valid GraphQL ") +
+        "DocumentNode. You may need to use 'graphql-tag' or another method " +
+        "to convert your operation into a document") : globals.invariant(!!document && !!document.kind, 30);
+    var fragments = [];
+    var queries = [];
+    var mutations = [];
+    var subscriptions = [];
+    for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {
+        var x = _a[_i];
+        if (x.kind === 'FragmentDefinition') {
+            fragments.push(x);
+            continue;
+        }
+        if (x.kind === 'OperationDefinition') {
+            switch (x.operation) {
+                case 'query':
+                    queries.push(x);
+                    break;
+                case 'mutation':
+                    mutations.push(x);
+                    break;
+                case 'subscription':
+                    subscriptions.push(x);
+                    break;
+            }
+        }
+    }
+    __DEV__ ? globals.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
+        "You must include a query, subscription or mutation as well") : globals.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), 31);
+    __DEV__ ? globals.invariant(queries.length + mutations.length + subscriptions.length <= 1, "react-apollo only supports a query, subscription, or a mutation per HOC. " +
+        "".concat(document, " had ").concat(queries.length, " queries, ").concat(subscriptions.length, " ") +
+        "subscriptions and ".concat(mutations.length, " mutations. ") +
+        "You can use 'compose' to join multiple operation types to a component") : globals.invariant(queries.length + mutations.length + subscriptions.length <= 1, 32);
+    type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
+    if (!queries.length && !mutations.length)
+        type = exports.DocumentType.Subscription;
+    var definitions = queries.length
+        ? queries
+        : mutations.length
+            ? mutations
+            : subscriptions;
+    __DEV__ ? globals.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. ".concat(document, " had ") +
+        "".concat(definitions.length, " definitions. ") +
+        "You can use 'compose' to join multiple operation types to a component") : globals.invariant(definitions.length === 1, 33);
+    var definition = definitions[0];
+    variables = definition.variableDefinitions || [];
+    if (definition.name && definition.name.kind === 'Name') {
+        name = definition.name.value;
+    }
+    else {
+        name = 'data';
+    }
+    var payload = { name: name, type: type, variables: variables };
+    cache.set(document, payload);
+    return payload;
+}
+function verifyDocumentType(document, type) {
+    var operation = parser(document);
+    var requiredOperationName = operationName(type);
+    var usedOperationName = operationName(operation.type);
+    __DEV__ ? globals.invariant(operation.type === type, "Running a ".concat(requiredOperationName, " requires a graphql ") +
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : globals.invariant(operation.type === type, 34);
+}
+
+exports.operationName = operationName;
+exports.parser = parser;
+exports.verifyDocumentType = verifyDocumentType;
+//# sourceMappingURL=parser.cjs.map

package/react/react.cjs.native.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utilities/globals');
+var context = require('./context');
+var hooks = require('./hooks');
+var parser = require('./parser');
+
+
+
+exports.ApolloConsumer = context.ApolloConsumer;
+exports.ApolloProvider = context.ApolloProvider;
+exports.getApolloContext = context.getApolloContext;
+exports.resetApolloContext = context.resetApolloContext;
+exports.DocumentType = parser.DocumentType;
+exports.operationName = parser.operationName;
+exports.parser = parser.parser;
+for (var k in hooks) {
+	if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = hooks[k];
+}
+//# sourceMappingURL=react.cjs.map

package/react/ssr/ssr.cjs.native.js

@@ -0,0 +1,150 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var context = require('../context');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function makeDefaultQueryInfo() {
+    return {
+        seen: false,
+        observable: null
+    };
+}
+var RenderPromises = (function () {
+    function RenderPromises() {
+        this.queryPromises = new Map();
+        this.queryInfoTrie = new Map();
+        this.stopped = false;
+    }
+    RenderPromises.prototype.stop = function () {
+        if (!this.stopped) {
+            this.queryPromises.clear();
+            this.queryInfoTrie.clear();
+            this.stopped = true;
+        }
+    };
+    RenderPromises.prototype.registerSSRObservable = function (observable) {
+        if (this.stopped)
+            return;
+        this.lookupQueryInfo(observable.options).observable = observable;
+    };
+    RenderPromises.prototype.getSSRObservable = function (props) {
+        return this.lookupQueryInfo(props).observable;
+    };
+    RenderPromises.prototype.addQueryPromise = function (queryInstance, finish) {
+        if (!this.stopped) {
+            var info = this.lookupQueryInfo(queryInstance.getOptions());
+            if (!info.seen) {
+                this.queryPromises.set(queryInstance.getOptions(), new Promise(function (resolve) {
+                    resolve(queryInstance.fetchData());
+                }));
+                return null;
+            }
+        }
+        return finish ? finish() : null;
+    };
+    RenderPromises.prototype.addObservableQueryPromise = function (obsQuery) {
+        return this.addQueryPromise({
+            getOptions: function () { return obsQuery.options; },
+            fetchData: function () { return new Promise(function (resolve) {
+                var sub = obsQuery.subscribe({
+                    next: function (result) {
+                        if (!result.loading) {
+                            resolve();
+                            sub.unsubscribe();
+                        }
+                    },
+                    error: function () {
+                        resolve();
+                        sub.unsubscribe();
+                    },
+                    complete: function () {
+                        resolve();
+                    },
+                });
+            }); },
+        });
+    };
+    RenderPromises.prototype.hasPromises = function () {
+        return this.queryPromises.size > 0;
+    };
+    RenderPromises.prototype.consumeAndAwaitPromises = function () {
+        var _this = this;
+        var promises = [];
+        this.queryPromises.forEach(function (promise, queryInstance) {
+            _this.lookupQueryInfo(queryInstance).seen = true;
+            promises.push(promise);
+        });
+        this.queryPromises.clear();
+        return Promise.all(promises);
+    };
+    RenderPromises.prototype.lookupQueryInfo = function (props) {
+        var queryInfoTrie = this.queryInfoTrie;
+        var query = props.query, variables = props.variables;
+        var varMap = queryInfoTrie.get(query) || new Map();
+        if (!queryInfoTrie.has(query))
+            queryInfoTrie.set(query, varMap);
+        var variablesString = JSON.stringify(variables);
+        var info = varMap.get(variablesString) || makeDefaultQueryInfo();
+        if (!varMap.has(variablesString))
+            varMap.set(variablesString, info);
+        return info;
+    };
+    return RenderPromises;
+}());
+
+function getDataFromTree(tree, context) {
+    if (context === void 0) { context = {}; }
+    return getMarkupFromTree({
+        tree: tree,
+        context: context,
+        renderFunction: require('react-dom/server').renderToStaticMarkup
+    });
+}
+function getMarkupFromTree(_a) {
+    var tree = _a.tree, _b = _a.context, context$1 = _b === void 0 ? {} : _b, _c = _a.renderFunction, renderFunction = _c === void 0 ? require('react-dom/server').renderToStaticMarkup : _c;
+    var renderPromises = new RenderPromises();
+    function process() {
+        var ApolloContext = context.getApolloContext();
+        return new Promise(function (resolve) {
+            var element = React__namespace.createElement(ApolloContext.Provider, { value: tslib.__assign(tslib.__assign({}, context$1), { renderPromises: renderPromises }) }, tree);
+            resolve(renderFunction(element));
+        }).then(function (html) {
+            return renderPromises.hasPromises()
+                ? renderPromises.consumeAndAwaitPromises().then(process)
+                : html;
+        }).finally(function () {
+            renderPromises.stop();
+        });
+    }
+    return Promise.resolve().then(process);
+}
+
+function renderToStringWithData(component) {
+    return getMarkupFromTree({
+        tree: component,
+        renderFunction: require('react-dom/server').renderToString
+    });
+}
+
+exports.RenderPromises = RenderPromises;
+exports.getDataFromTree = getDataFromTree;
+exports.getMarkupFromTree = getMarkupFromTree;
+exports.renderToStringWithData = renderToStringWithData;
+//# sourceMappingURL=ssr.cjs.map

package/testing/core/core.cjs.native.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var globals = require('../../utilities/globals');
+var graphql = require('graphql');
+var equality = require('@wry/equality');
+var core = require('../../link/core');
+var utilities = require('../../utilities');
+var core$1 = require('../../core');
+var cache = require('../../cache');
+
+function requestToKey(request, addTypename) {
+    var queryString = request.query &&
+        graphql.print(addTypename ? utilities.addTypenameToDocument(request.query) : request.query);
+    var requestKey = { query: queryString };
+    return JSON.stringify(requestKey);
+}
+var MockLink = (function (_super) {
+    tslib.__extends(MockLink, _super);
+    function MockLink(mockedResponses, addTypename) {
+        if (addTypename === void 0) { addTypename = true; }
+        var _this = _super.call(this) || this;
+        _this.addTypename = true;
+        _this.mockedResponsesByKey = {};
+        _this.addTypename = addTypename;
+        if (mockedResponses) {
+            mockedResponses.forEach(function (mockedResponse) {
+                _this.addMockedResponse(mockedResponse);
+            });
+        }
+        return _this;
+    }
+    MockLink.prototype.addMockedResponse = function (mockedResponse) {
+        var normalizedMockedResponse = this.normalizeMockedResponse(mockedResponse);
+        var key = requestToKey(normalizedMockedResponse.request, this.addTypename);
+        var mockedResponses = this.mockedResponsesByKey[key];
+        if (!mockedResponses) {
+            mockedResponses = [];
+            this.mockedResponsesByKey[key] = mockedResponses;
+        }
+        mockedResponses.push(normalizedMockedResponse);
+    };
+    MockLink.prototype.request = function (operation) {
+        var _this = this;
+        this.operation = operation;
+        var key = requestToKey(operation, this.addTypename);
+        var unmatchedVars = [];
+        var requestVariables = operation.variables || {};
+        var mockedResponses = this.mockedResponsesByKey[key];
+        var responseIndex = mockedResponses ? mockedResponses.findIndex(function (res, index) {
+            var mockedResponseVars = res.request.variables || {};
+            if (equality.equal(requestVariables, mockedResponseVars)) {
+                return true;
+            }
+            unmatchedVars.push(mockedResponseVars);
+            return false;
+        }) : -1;
+        var response = responseIndex >= 0
+            ? mockedResponses[responseIndex]
+            : void 0;
+        var configError;
+        if (!response) {
+            configError = new Error("No more mocked responses for the query: ".concat(graphql.print(operation.query), "\nExpected variables: ").concat(utilities.stringifyForDisplay(operation.variables), "\n").concat(unmatchedVars.length > 0 ? "\nFailed to match ".concat(unmatchedVars.length, " mock").concat(unmatchedVars.length === 1 ? "" : "s", " for this query, which had the following variables:\n").concat(unmatchedVars.map(function (d) { return "  ".concat(utilities.stringifyForDisplay(d)); }).join('\n'), "\n") : ""));
+        }
+        else {
+            mockedResponses.splice(responseIndex, 1);
+            var newData = response.newData;
+            if (newData) {
+                response.result = newData();
+                mockedResponses.push(response);
+            }
+            if (!response.result && !response.error) {
+                configError = new Error("Mocked response should contain either result or error: ".concat(key));
+            }
+        }
+        return new utilities.Observable(function (observer) {
+            var timer = setTimeout(function () {
+                if (configError) {
+                    try {
+                        if (_this.onError(configError, observer) !== false) {
+                            throw configError;
+                        }
+                    }
+                    catch (error) {
+                        observer.error(error);
+                    }
+                }
+                else if (response) {
+                    if (response.error) {
+                        observer.error(response.error);
+                    }
+                    else {
+                        if (response.result) {
+                            observer.next(typeof response.result === 'function'
+                                ? response.result()
+                                : response.result);
+                        }
+                        observer.complete();
+                    }
+                }
+            }, response && response.delay || 0);
+            return function () {
+                clearTimeout(timer);
+            };
+        });
+    };
+    MockLink.prototype.normalizeMockedResponse = function (mockedResponse) {
+        var newMockedResponse = utilities.cloneDeep(mockedResponse);
+        var queryWithoutConnection = utilities.removeConnectionDirectiveFromDocument(newMockedResponse.request.query);
+        __DEV__ ? globals.invariant(queryWithoutConnection, "query is required") : globals.invariant(queryWithoutConnection, 35);
+        newMockedResponse.request.query = queryWithoutConnection;
+        var query = utilities.removeClientSetsFromDocument(newMockedResponse.request.query);
+        if (query) {
+            newMockedResponse.request.query = query;
+        }
+        return newMockedResponse;
+    };
+    return MockLink;
+}(core.ApolloLink));
+function mockSingleLink() {
+    var mockedResponses = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        mockedResponses[_i] = arguments[_i];
+    }
+    var maybeTypename = mockedResponses[mockedResponses.length - 1];
+    var mocks = mockedResponses.slice(0, mockedResponses.length - 1);
+    if (typeof maybeTypename !== 'boolean') {
+        mocks = mockedResponses;
+        maybeTypename = true;
+    }
+    return new MockLink(mocks, maybeTypename);
+}
+
+var MockSubscriptionLink = (function (_super) {
+    tslib.__extends(MockSubscriptionLink, _super);
+    function MockSubscriptionLink() {
+        var _this = _super.call(this) || this;
+        _this.unsubscribers = [];
+        _this.setups = [];
+        _this.observers = [];
+        return _this;
+    }
+    MockSubscriptionLink.prototype.request = function (operation) {
+        var _this = this;
+        this.operation = operation;
+        return new utilities.Observable(function (observer) {
+            _this.setups.forEach(function (x) { return x(); });
+            _this.observers.push(observer);
+            return function () {
+                _this.unsubscribers.forEach(function (x) { return x(); });
+            };
+        });
+    };
+    MockSubscriptionLink.prototype.simulateResult = function (result, complete) {
+        var _this = this;
+        if (complete === void 0) { complete = false; }
+        setTimeout(function () {
+            var observers = _this.observers;
+            if (!observers.length)
+                throw new Error('subscription torn down');
+            observers.forEach(function (observer) {
+                if (result.result && observer.next)
+                    observer.next(result.result);
+                if (result.error && observer.error)
+                    observer.error(result.error);
+                if (complete && observer.complete)
+                    observer.complete();
+            });
+        }, result.delay || 0);
+    };
+    MockSubscriptionLink.prototype.simulateComplete = function () {
+        var observers = this.observers;
+        if (!observers.length)
+            throw new Error('subscription torn down');
+        observers.forEach(function (observer) {
+            if (observer.complete)
+                observer.complete();
+        });
+    };
+    MockSubscriptionLink.prototype.onSetup = function (listener) {
+        this.setups = this.setups.concat([listener]);
+    };
+    MockSubscriptionLink.prototype.onUnsubscribe = function (listener) {
+        this.unsubscribers = this.unsubscribers.concat([listener]);
+    };
+    return MockSubscriptionLink;
+}(core.ApolloLink));
+function mockObservableLink() {
+    return new MockSubscriptionLink();
+}
+
+function createMockClient(data, query, variables) {
+    if (variables === void 0) { variables = {}; }
+    return new core$1.ApolloClient({
+        link: mockSingleLink({
+            request: { query: query, variables: variables },
+            result: { data: data },
+        }).setOnError(function (error) { throw error; }),
+        cache: new cache.InMemoryCache({ addTypename: false }),
+    });
+}
+
+function subscribeAndCount(reject, observable, cb) {
+    var queue = Promise.resolve();
+    var handleCount = 0;
+    var subscription = utilities.asyncMap(observable, function (result) {
+        return queue = queue.then(function () {
+            return cb(++handleCount, result);
+        }).catch(error);
+    }).subscribe({ error: error });
+    function error(e) {
+        subscription.unsubscribe();
+        reject(e);
+    }
+    return subscription;
+}
+
+function wrap(key) {
+    return function (message, callback, timeout) { return (key ? it[key] : it)(message, function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return callback.call(_this, resolve, reject); });
+    }, timeout); };
+}
+var wrappedIt = wrap();
+var itAsync = Object.assign(function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return wrappedIt.apply(this, args);
+}, {
+    only: wrap("only"),
+    skip: wrap("skip"),
+    todo: wrap("todo"),
+});
+
+function wrapTestFunction(fn, consoleMethodName) {
+    return function () {
+        var _this = this;
+        var args = arguments;
+        var spy = jest.spyOn(console, consoleMethodName);
+        spy.mockImplementation(function () { });
+        return new Promise(function (resolve) {
+            resolve(fn === null || fn === void 0 ? void 0 : fn.apply(_this, args));
+        }).finally(function () {
+            expect(spy).toMatchSnapshot();
+            spy.mockReset();
+        });
+    };
+}
+function withErrorSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "error");
+    return it.apply(void 0, args);
+}
+function withWarningSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "warn");
+    return it.apply(void 0, args);
+}
+function withLogSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "log");
+    return it.apply(void 0, args);
+}
+
+exports.MockLink = MockLink;
+exports.MockSubscriptionLink = MockSubscriptionLink;
+exports.createMockClient = createMockClient;
+exports.itAsync = itAsync;
+exports.mockObservableLink = mockObservableLink;
+exports.mockSingleLink = mockSingleLink;
+exports.subscribeAndCount = subscribeAndCount;
+exports.withErrorSpy = withErrorSpy;
+exports.withLogSpy = withLogSpy;
+exports.withWarningSpy = withWarningSpy;
+//# sourceMappingURL=core.cjs.map

package/testing/testing.cjs.native.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utilities/globals');
+var tslib = require('tslib');
+var React = require('react');
+var core$1 = require('../core');
+var cache = require('../cache');
+var context = require('../react/context');
+var core = require('./core');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var MockedProvider = (function (_super) {
+    tslib.__extends(MockedProvider, _super);
+    function MockedProvider(props) {
+        var _this = _super.call(this, props) || this;
+        var _a = _this.props, mocks = _a.mocks, addTypename = _a.addTypename, defaultOptions = _a.defaultOptions, cache$1 = _a.cache, resolvers = _a.resolvers, link = _a.link;
+        var client = new core$1.ApolloClient({
+            cache: cache$1 || new cache.InMemoryCache({ addTypename: addTypename }),
+            defaultOptions: defaultOptions,
+            link: link || new core.MockLink(mocks || [], addTypename),
+            resolvers: resolvers,
+        });
+        _this.state = { client: client };
+        return _this;
+    }
+    MockedProvider.prototype.render = function () {
+        var _a = this.props, children = _a.children, childProps = _a.childProps;
+        return React__namespace.isValidElement(children) ? (React__namespace.createElement(context.ApolloProvider, { client: this.state.client }, React__namespace.cloneElement(React__namespace.Children.only(children), tslib.__assign({}, childProps)))) : null;
+    };
+    MockedProvider.prototype.componentWillUnmount = function () {
+        this.state.client.stop();
+    };
+    MockedProvider.defaultProps = {
+        addTypename: true
+    };
+    return MockedProvider;
+}(React__namespace.Component));
+
+exports.MockedProvider = MockedProvider;
+for (var k in core) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];
+}
+//# sourceMappingURL=testing.cjs.map