@apollo/client 3.6.2 → 3.6.5

package/link/retry/retry.cjs.native.js

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+function buildDelayFunction(delayOptions) {
+    var _a = delayOptions || {}, _b = _a.initial, initial = _b === void 0 ? 300 : _b, _c = _a.jitter, jitter = _c === void 0 ? true : _c, _d = _a.max, max = _d === void 0 ? Infinity : _d;
+    var baseDelay = jitter ? initial : initial / 2;
+    return function delayFunction(count) {
+        var delay = Math.min(max, baseDelay * Math.pow(2, count));
+        if (jitter) {
+            delay = Math.random() * delay;
+        }
+        return delay;
+    };
+}
+
+function buildRetryFunction(retryOptions) {
+    var _a = retryOptions || {}, retryIf = _a.retryIf, _b = _a.max, max = _b === void 0 ? 5 : _b;
+    return function retryFunction(count, operation, error) {
+        if (count >= max)
+            return false;
+        return retryIf ? retryIf(error, operation) : !!error;
+    };
+}
+
+var RetryableOperation = (function () {
+    function RetryableOperation(operation, nextLink, delayFor, retryIf) {
+        var _this = this;
+        this.operation = operation;
+        this.nextLink = nextLink;
+        this.delayFor = delayFor;
+        this.retryIf = retryIf;
+        this.retryCount = 0;
+        this.values = [];
+        this.complete = false;
+        this.canceled = false;
+        this.observers = [];
+        this.currentSubscription = null;
+        this.onNext = function (value) {
+            _this.values.push(value);
+            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                if (!observer)
+                    continue;
+                observer.next(value);
+            }
+        };
+        this.onComplete = function () {
+            _this.complete = true;
+            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                if (!observer)
+                    continue;
+                observer.complete();
+            }
+        };
+        this.onError = function (error) { return tslib.__awaiter(_this, void 0, void 0, function () {
+            var shouldRetry, _i, _a, observer;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.retryCount += 1;
+                        return [4, this.retryIf(this.retryCount, this.operation, error)];
+                    case 1:
+                        shouldRetry = _b.sent();
+                        if (shouldRetry) {
+                            this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));
+                            return [2];
+                        }
+                        this.error = error;
+                        for (_i = 0, _a = this.observers; _i < _a.length; _i++) {
+                            observer = _a[_i];
+                            if (!observer)
+                                continue;
+                            observer.error(error);
+                        }
+                        return [2];
+                }
+            });
+        }); };
+    }
+    RetryableOperation.prototype.subscribe = function (observer) {
+        if (this.canceled) {
+            throw new Error("Subscribing to a retryable link that was canceled is not supported");
+        }
+        this.observers.push(observer);
+        for (var _i = 0, _a = this.values; _i < _a.length; _i++) {
+            var value = _a[_i];
+            observer.next(value);
+        }
+        if (this.complete) {
+            observer.complete();
+        }
+        else if (this.error) {
+            observer.error(this.error);
+        }
+    };
+    RetryableOperation.prototype.unsubscribe = function (observer) {
+        var index = this.observers.indexOf(observer);
+        if (index < 0) {
+            throw new Error("RetryLink BUG! Attempting to unsubscribe unknown observer!");
+        }
+        this.observers[index] = null;
+        if (this.observers.every(function (o) { return o === null; })) {
+            this.cancel();
+        }
+    };
+    RetryableOperation.prototype.start = function () {
+        if (this.currentSubscription)
+            return;
+        this.try();
+    };
+    RetryableOperation.prototype.cancel = function () {
+        if (this.currentSubscription) {
+            this.currentSubscription.unsubscribe();
+        }
+        clearTimeout(this.timerId);
+        this.timerId = undefined;
+        this.currentSubscription = null;
+        this.canceled = true;
+    };
+    RetryableOperation.prototype.try = function () {
+        this.currentSubscription = this.nextLink(this.operation).subscribe({
+            next: this.onNext,
+            error: this.onError,
+            complete: this.onComplete,
+        });
+    };
+    RetryableOperation.prototype.scheduleRetry = function (delay) {
+        var _this = this;
+        if (this.timerId) {
+            throw new Error("RetryLink BUG! Encountered overlapping retries");
+        }
+        this.timerId = setTimeout(function () {
+            _this.timerId = undefined;
+            _this.try();
+        }, delay);
+    };
+    return RetryableOperation;
+}());
+var RetryLink = (function (_super) {
+    tslib.__extends(RetryLink, _super);
+    function RetryLink(options) {
+        var _this = _super.call(this) || this;
+        var _a = options || {}, attempts = _a.attempts, delay = _a.delay;
+        _this.delayFor =
+            typeof delay === 'function' ? delay : buildDelayFunction(delay);
+        _this.retryIf =
+            typeof attempts === 'function' ? attempts : buildRetryFunction(attempts);
+        return _this;
+    }
+    RetryLink.prototype.request = function (operation, nextLink) {
+        var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);
+        retryable.start();
+        return new utilities.Observable(function (observer) {
+            retryable.subscribe(observer);
+            return function () {
+                retryable.unsubscribe(observer);
+            };
+        });
+    };
+    return RetryLink;
+}(core.ApolloLink));
+
+exports.RetryLink = RetryLink;
+//# sourceMappingURL=retry.cjs.map

package/link/schema/schema.cjs.native.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var graphql = require('graphql');
+var core = require('../core');
+var utilities = require('../../utilities');
+
+var SchemaLink = (function (_super) {
+    tslib.__extends(SchemaLink, _super);
+    function SchemaLink(options) {
+        var _this = _super.call(this) || this;
+        _this.schema = options.schema;
+        _this.rootValue = options.rootValue;
+        _this.context = options.context;
+        _this.validate = !!options.validate;
+        return _this;
+    }
+    SchemaLink.prototype.request = function (operation) {
+        var _this = this;
+        return new utilities.Observable(function (observer) {
+            new Promise(function (resolve) { return resolve(typeof _this.context === 'function'
+                ? _this.context(operation)
+                : _this.context); }).then(function (context) {
+                if (_this.validate) {
+                    var validationErrors = graphql.validate(_this.schema, operation.query);
+                    if (validationErrors.length > 0) {
+                        return { errors: validationErrors };
+                    }
+                }
+                return graphql.execute({
+                    schema: _this.schema,
+                    document: operation.query,
+                    rootValue: _this.rootValue,
+                    contextValue: context,
+                    variableValues: operation.variables,
+                    operationName: operation.operationName,
+                });
+            }).then(function (data) {
+                if (!observer.closed) {
+                    observer.next(data);
+                    observer.complete();
+                }
+            }).catch(function (error) {
+                if (!observer.closed) {
+                    observer.error(error);
+                }
+            });
+        });
+    };
+    return SchemaLink;
+}(core.ApolloLink));
+
+exports.SchemaLink = SchemaLink;
+//# sourceMappingURL=schema.cjs.map

package/link/subscriptions/subscriptions.cjs.native.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var graphql = require('graphql');
+var core = require('../core');
+var utilities = require('../../utilities');
+var errors = require('../../errors');
+
+function isLikeCloseEvent(val) {
+    return utilities.isNonNullObject(val) && 'code' in val && 'reason' in val;
+}
+var GraphQLWsLink = (function (_super) {
+    tslib.__extends(GraphQLWsLink, _super);
+    function GraphQLWsLink(client) {
+        var _this = _super.call(this) || this;
+        _this.client = client;
+        return _this;
+    }
+    GraphQLWsLink.prototype.request = function (operation) {
+        var _this = this;
+        return new utilities.Observable(function (observer) {
+            return _this.client.subscribe(tslib.__assign(tslib.__assign({}, operation), { query: graphql.print(operation.query) }), {
+                next: observer.next.bind(observer),
+                complete: observer.complete.bind(observer),
+                error: function (err) {
+                    if (err instanceof Error) {
+                        return observer.error(err);
+                    }
+                    if (isLikeCloseEvent(err)) {
+                        return observer.error(new Error("Socket closed with event ".concat(err.code, " ").concat(err.reason || "")));
+                    }
+                    return observer.error(new errors.ApolloError({
+                        graphQLErrors: Array.isArray(err) ? err : [err],
+                    }));
+                },
+            });
+        });
+    };
+    return GraphQLWsLink;
+}(core.ApolloLink));
+
+exports.GraphQLWsLink = GraphQLWsLink;
+//# sourceMappingURL=subscriptions.cjs.map

package/link/utils/utils.cjs.native.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var utilities = require('../../utilities');
+var tslib = require('tslib');
+
+function fromError(errorValue) {
+    return new utilities.Observable(function (observer) {
+        observer.error(errorValue);
+    });
+}
+
+function toPromise(observable) {
+    var completed = false;
+    return new Promise(function (resolve, reject) {
+        observable.subscribe({
+            next: function (data) {
+                if (completed) {
+                    __DEV__ && globals.invariant.warn("Promise Wrapper does not support multiple results from Observable");
+                }
+                else {
+                    completed = true;
+                    resolve(data);
+                }
+            },
+            error: reject,
+        });
+    });
+}
+
+function fromPromise(promise) {
+    return new utilities.Observable(function (observer) {
+        promise
+            .then(function (value) {
+            observer.next(value);
+            observer.complete();
+        })
+            .catch(observer.error.bind(observer));
+    });
+}
+
+var throwServerError = function (response, result, message) {
+    var error = new Error(message);
+    error.name = 'ServerError';
+    error.response = response;
+    error.statusCode = response.status;
+    error.result = result;
+    throw error;
+};
+
+function validateOperation(operation) {
+    var OPERATION_FIELDS = [
+        'query',
+        'operationName',
+        'variables',
+        'extensions',
+        'context',
+    ];
+    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {
+        var key = _a[_i];
+        if (OPERATION_FIELDS.indexOf(key) < 0) {
+            throw __DEV__ ? new globals.InvariantError("illegal argument: ".concat(key)) : new globals.InvariantError(24);
+        }
+    }
+    return operation;
+}
+
+function createOperation(starting, operation) {
+    var context = tslib.__assign({}, starting);
+    var setContext = function (next) {
+        if (typeof next === 'function') {
+            context = tslib.__assign(tslib.__assign({}, context), next(context));
+        }
+        else {
+            context = tslib.__assign(tslib.__assign({}, context), next);
+        }
+    };
+    var getContext = function () { return (tslib.__assign({}, context)); };
+    Object.defineProperty(operation, 'setContext', {
+        enumerable: false,
+        value: setContext,
+    });
+    Object.defineProperty(operation, 'getContext', {
+        enumerable: false,
+        value: getContext,
+    });
+    return operation;
+}
+
+function transformOperation(operation) {
+    var transformedOperation = {
+        variables: operation.variables || {},
+        extensions: operation.extensions || {},
+        operationName: operation.operationName,
+        query: operation.query,
+    };
+    if (!transformedOperation.operationName) {
+        transformedOperation.operationName =
+            typeof transformedOperation.query !== 'string'
+                ? utilities.getOperationName(transformedOperation.query) || undefined
+                : '';
+    }
+    return transformedOperation;
+}
+
+exports.createOperation = createOperation;
+exports.fromError = fromError;
+exports.fromPromise = fromPromise;
+exports.throwServerError = throwServerError;
+exports.toPromise = toPromise;
+exports.transformOperation = transformOperation;
+exports.validateOperation = validateOperation;
+//# sourceMappingURL=utils.cjs.map

package/link/ws/ws.cjs.native.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var subscriptionsTransportWs = require('subscriptions-transport-ws');
+var core = require('../core');
+
+var WebSocketLink = (function (_super) {
+    tslib.__extends(WebSocketLink, _super);
+    function WebSocketLink(paramsOrClient) {
+        var _this = _super.call(this) || this;
+        if (paramsOrClient instanceof subscriptionsTransportWs.SubscriptionClient) {
+            _this.subscriptionClient = paramsOrClient;
+        }
+        else {
+            _this.subscriptionClient = new subscriptionsTransportWs.SubscriptionClient(paramsOrClient.uri, paramsOrClient.options, paramsOrClient.webSocketImpl);
+        }
+        return _this;
+    }
+    WebSocketLink.prototype.request = function (operation) {
+        return this.subscriptionClient.request(operation);
+    };
+    return WebSocketLink;
+}(core.ApolloLink));
+
+exports.WebSocketLink = WebSocketLink;
+//# sourceMappingURL=ws.cjs.map

package/main.cjs.native.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('./core');
+var react = require('./react');
+
+
+
+for (var k in core) {
+	if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];
+}
+for (var k in react) {
+	if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = react[k];
+}
+//# sourceMappingURL=main.cjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/client",
-  "version": "3.6.2",
+  "version": "3.6.5",
   "description": "A fully-featured caching GraphQL client.",
   "private": false,
   "keywords": [
@@ -55,14 +55,13 @@
     "optimism": "^0.16.1",
     "prop-types": "^15.7.2",
     "symbol-observable": "^4.0.0",
-    "ts-invariant": "^0.10.0",
+    "ts-invariant": "^0.10.3",
     "tslib": "^2.3.0",
-    "use-sync-external-store": "^1.0.0",
-    "zen-observable-ts": "^1.2.0"
+    "zen-observable-ts": "^1.2.5"
   },
   "devDependencies": {
-    "@babel/parser": "7.17.10",
-    "@graphql-tools/schema": "8.3.10",
+    "@babel/parser": "7.18.0",
+    "@graphql-tools/schema": "8.3.13",
     "@rollup/plugin-node-resolve": "11.2.1",
     "@testing-library/react": "12.1.5",
     "@testing-library/react-hooks": "8.0.0",
@@ -70,20 +69,20 @@
     "@types/fetch-mock": "7.3.5",
     "@types/glob": "7.2.0",
     "@types/hoist-non-react-statics": "3.3.1",
-    "@types/jest": "27.4.1",
+    "@types/jest": "27.5.1",
     "@types/lodash": "4.14.182",
-    "@types/node": "16.11.33",
-    "@types/react": "17.0.44",
-    "@types/react-dom": "17.0.16",
-    "@types/use-sync-external-store": "0.0.3",
+    "@types/node": "16.11.36",
+    "@types/react": "17.0.45",
+    "@types/react-dom": "17.0.17",
+    "@types/use-sync-external-store": "^0.0.3",
     "acorn": "8.7.1",
     "bundlesize": "0.18.1",
     "cross-fetch": "3.1.5",
     "crypto-hash": "1.3.0",
     "fetch-mock": "9.11.0",
-    "glob": "8.0.1",
-    "graphql": "16.4.0",
-    "graphql-ws": "5.8.1",
+    "glob": "8.0.3",
+    "graphql": "16.5.0",
+    "graphql-ws": "5.8.2",
     "jest": "27.5.1",
     "jest-fetch-mock": "3.0.3",
     "jest-junit": "13.2.0",
@@ -93,13 +92,13 @@
     "recast": "0.21.1",
     "resolve": "1.22.0",
     "rimraf": "3.0.2",
-    "rollup": "2.71.1",
+    "rollup": "2.74.1",
     "rollup-plugin-terser": "7.0.2",
     "rxjs": "7.5.5",
     "subscriptions-transport-ws": "0.11.0",
     "terser": "5.13.1",
-    "ts-jest": "27.1.4",
-    "ts-node": "10.7.0",
+    "ts-jest": "27.1.5",
+    "ts-node": "10.8.0",
     "typescript": "4.6.4",
     "wait-for-observables": "1.0.3",
     "whatwg-fetch": "3.6.2"

package/react/components/components.cjs.native.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var PropTypes = require('prop-types');
+var hooks = require('../hooks');
+
+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 PropTypes__namespace = /*#__PURE__*/_interopNamespace(PropTypes);
+
+function Query(props) {
+    var children = props.children, query = props.query, options = tslib.__rest(props, ["children", "query"]);
+    var result = hooks.useQuery(query, options);
+    return result ? children(result) : null;
+}
+Query.propTypes = {
+    client: PropTypes__namespace.object,
+    children: PropTypes__namespace.func.isRequired,
+    fetchPolicy: PropTypes__namespace.string,
+    notifyOnNetworkStatusChange: PropTypes__namespace.bool,
+    onCompleted: PropTypes__namespace.func,
+    onError: PropTypes__namespace.func,
+    pollInterval: PropTypes__namespace.number,
+    query: PropTypes__namespace.object.isRequired,
+    variables: PropTypes__namespace.object,
+    ssr: PropTypes__namespace.bool,
+    partialRefetch: PropTypes__namespace.bool,
+    returnPartialData: PropTypes__namespace.bool
+};
+
+function Mutation(props) {
+    var _a = hooks.useMutation(props.mutation, props), runMutation = _a[0], result = _a[1];
+    return props.children ? props.children(runMutation, result) : null;
+}
+Mutation.propTypes = {
+    mutation: PropTypes__namespace.object.isRequired,
+    variables: PropTypes__namespace.object,
+    optimisticResponse: PropTypes__namespace.oneOfType([PropTypes__namespace.object, PropTypes__namespace.func]),
+    refetchQueries: PropTypes__namespace.oneOfType([
+        PropTypes__namespace.arrayOf(PropTypes__namespace.oneOfType([PropTypes__namespace.string, PropTypes__namespace.object])),
+        PropTypes__namespace.func
+    ]),
+    awaitRefetchQueries: PropTypes__namespace.bool,
+    update: PropTypes__namespace.func,
+    children: PropTypes__namespace.func.isRequired,
+    onCompleted: PropTypes__namespace.func,
+    onError: PropTypes__namespace.func,
+    fetchPolicy: PropTypes__namespace.string,
+};
+
+function Subscription(props) {
+    var result = hooks.useSubscription(props.subscription, props);
+    return props.children && result ? props.children(result) : null;
+}
+Subscription.propTypes = {
+    subscription: PropTypes__namespace.object.isRequired,
+    variables: PropTypes__namespace.object,
+    children: PropTypes__namespace.func,
+    onSubscriptionData: PropTypes__namespace.func,
+    onSubscriptionComplete: PropTypes__namespace.func,
+    shouldResubscribe: PropTypes__namespace.oneOfType([PropTypes__namespace.func, PropTypes__namespace.bool])
+};
+
+exports.Mutation = Mutation;
+exports.Query = Query;
+exports.Subscription = Subscription;
+//# sourceMappingURL=components.cjs.map

package/react/context/context.cjs.native.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var React = require('react');
+var utilities = require('../../utilities');
+
+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 contextKey = utilities.canUseSymbol
+    ? Symbol.for('__APOLLO_CONTEXT__')
+    : '__APOLLO_CONTEXT__';
+function getApolloContext() {
+    var context = React__namespace.createContext[contextKey];
+    if (!context) {
+        Object.defineProperty(React__namespace.createContext, contextKey, {
+            value: context = React__namespace.createContext({}),
+            enumerable: false,
+            writable: false,
+            configurable: true,
+        });
+        context.displayName = 'ApolloContext';
+    }
+    return context;
+}
+
+var ApolloConsumer = function (props) {
+    var ApolloContext = getApolloContext();
+    return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
+        __DEV__ ? globals.invariant(context && context.client, 'Could not find "client" in the context of ApolloConsumer. ' +
+            'Wrap the root component in an <ApolloProvider>.') : globals.invariant(context && context.client, 25);
+        return props.children(context.client);
+    }));
+};
+
+var ApolloProvider = function (_a) {
+    var client = _a.client, children = _a.children;
+    var ApolloContext = getApolloContext();
+    return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {
+        if (context === void 0) { context = {}; }
+        if (client && context.client !== client) {
+            context = Object.assign({}, context, { client: client });
+        }
+        __DEV__ ? globals.invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +
+            'sure you pass in your client via the "client" prop.') : globals.invariant(context.client, 26);
+        return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));
+    }));
+};
+
+exports.ApolloConsumer = ApolloConsumer;
+exports.ApolloProvider = ApolloProvider;
+exports.getApolloContext = getApolloContext;
+exports.resetApolloContext = getApolloContext;
+//# sourceMappingURL=context.cjs.map