@apollo/client 3.5.10 → 3.6.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/client",
-  "version": "3.5.10",
+  "version": "3.6.0-beta.10",
   "description": "A fully-featured caching GraphQL client.",
   "private": false,
   "keywords": [
@@ -55,32 +55,33 @@
     "optimism": "^0.16.1",
     "prop-types": "^15.7.2",
     "symbol-observable": "^4.0.0",
-    "ts-invariant": "^0.9.4",
+    "ts-invariant": "^0.10.0",
     "tslib": "^2.3.0",
     "zen-observable-ts": "^1.2.0"
   },
   "devDependencies": {
-    "@babel/parser": "7.17.3",
-    "@graphql-tools/schema": "8.3.1",
+    "@babel/parser": "7.17.8",
+    "@graphql-tools/schema": "8.3.5",
     "@rollup/plugin-node-resolve": "11.2.1",
-    "@testing-library/react": "12.1.3",
+    "@testing-library/react": "12.1.4",
     "@testing-library/react-hooks": "7.0.2",
     "@types/fast-json-stable-stringify": "2.0.0",
     "@types/fetch-mock": "7.3.5",
     "@types/glob": "7.2.0",
     "@types/hoist-non-react-statics": "3.3.1",
-    "@types/jest": "27.4.0",
-    "@types/lodash": "4.14.178",
-    "@types/node": "16.11.25",
-    "@types/react": "17.0.34",
-    "@types/react-dom": "17.0.2",
+    "@types/jest": "27.4.1",
+    "@types/lodash": "4.14.180",
+    "@types/node": "16.11.26",
+    "@types/react": "17.0.43",
+    "@types/react-dom": "17.0.14",
+    "acorn": "8.6.0",
     "bundlesize": "0.18.1",
     "cross-fetch": "3.1.5",
     "crypto-hash": "1.3.0",
     "fetch-mock": "9.11.0",
     "glob": "7.2.0",
     "graphql": "16.0.1",
-    "graphql-ws": "5.6.2",
+    "graphql-ws": "5.6.4",
     "jest": "27.5.1",
     "jest-fetch-mock": "3.0.3",
     "jest-junit": "13.0.0",
@@ -90,14 +91,14 @@
     "recast": "0.21.0",
     "resolve": "1.22.0",
     "rimraf": "3.0.2",
-    "rollup": "2.67.3",
+    "rollup": "2.70.1",
     "rollup-plugin-terser": "7.0.2",
     "rxjs": "6.6.7",
     "subscriptions-transport-ws": "0.11.0",
-    "terser": "5.10.0",
-    "ts-jest": "27.1.3",
-    "ts-node": "10.5.0",
-    "typescript": "4.5.5",
+    "terser": "5.12.1",
+    "ts-jest": "27.1.4",
+    "ts-node": "10.7.0",
+    "typescript": "4.6.3",
     "wait-for-observables": "1.0.3",
     "whatwg-fetch": "3.6.2"
   },

package/react/hooks/hooks.cjs

@@ -6,10 +6,15 @@ var globals = require('../../utilities/globals');
 var react = require('react');
 var context = require('../context');
 var tslib = require('tslib');
-var equality = require('@wry/equality');
-var core = require('../../core');
+var equal = require('@wry/equality');
 var errors = require('../../errors');
+var core = require('../../core');
 var parser = require('../parser');
+var utilities = require('../../utilities');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+var equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);
 
 function useApolloClient(override) {
     var context$1 = react.useContext(context.getApolloContext());
@@ -20,227 +25,274 @@ function useApolloClient(override) {
     return client;
 }
 
-function useQuery(query, options) {
-    var _a;
-    var context$1 = react.useContext(context.getApolloContext());
-    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
-    var defaultWatchQueryOptions = client.defaultOptions.watchQuery;
-    parser.verifyDocumentType(query, parser.DocumentType.Query);
-    var _b = react.useState(function () {
-        var watchQueryOptions = createWatchQueryOptions(query, options, defaultWatchQueryOptions);
-        var obsQuery = null;
-        if (context$1.renderPromises) {
-            obsQuery = context$1.renderPromises.getSSRObservable(watchQueryOptions);
+function useNormalizedOptions(optionsOrFunction) {
+    var optionsRef = react.useRef();
+    var options = optionsRef.current || Object.create(null);
+    if (typeof optionsOrFunction === "function") {
+        var newOptions = optionsOrFunction(options);
+        if (newOptions !== options) {
+            Object.assign(options, newOptions, newOptions.variables && {
+                variables: tslib.__assign(tslib.__assign({}, options.variables), newOptions.variables),
+            });
         }
-        if (!obsQuery) {
-            obsQuery = client.watchQuery(watchQueryOptions);
-            if (context$1.renderPromises) {
-                context$1.renderPromises.registerSSRObservable(obsQuery, watchQueryOptions);
-            }
+    }
+    else if (optionsOrFunction && !equal__default(optionsOrFunction, options)) {
+        options = optionsOrFunction;
+    }
+    return optionsRef.current = options;
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function useQuery(query, optionsOrFunction) {
+    var options = useNormalizedOptions(optionsOrFunction);
+    return useInternalState(useApolloClient(options.client), query).useQuery(options);
+}
+function useInternalState(client, query) {
+    var stateRef = react.useRef();
+    if (!stateRef.current ||
+        client !== stateRef.current.client ||
+        query !== stateRef.current.query) {
+        stateRef.current = new InternalState(client, query);
+    }
+    var state = stateRef.current;
+    var _a = react.useState(0); _a[0]; var setTick = _a[1];
+    state.forceUpdate = function () {
+        setTick(function (tick) { return tick + 1; });
+    };
+    return state;
+}
+var InternalState = (function () {
+    function InternalState(client, query) {
+        this.client = client;
+        this.query = query;
+        this.toQueryResultCache = new (utilities.canUseWeakMap ? WeakMap : Map)();
+        parser.verifyDocumentType(query, parser.DocumentType.Query);
+    }
+    InternalState.prototype.forceUpdate = function () {
+    };
+    InternalState.prototype.useQuery = function (options) {
+        this.useOptions(options);
+        var obsQuery = this.useObservableQuery();
+        this.useSubscriptionEffect(obsQuery);
+        var result = this.getCurrentResult();
+        this.unsafeHandlePartialRefetch(result);
+        return this.toQueryResult(result);
+    };
+    InternalState.prototype.useOptions = function (options) {
+        this.renderPromises = react.useContext(context.getApolloContext()).renderPromises;
+        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        if (!equal.equal(watchQueryOptions, this.watchQueryOptions)) {
+            this.watchQueryOptions = watchQueryOptions;
+        }
+        this.ssrDisabled = !!(options && (options.ssr === false ||
+            options.skip));
+        this.onCompleted = options
+            && options.onCompleted
+            || InternalState.prototype.onCompleted;
+        this.onError = options
+            && options.onError
+            || InternalState.prototype.onError;
+    };
+    InternalState.prototype.createWatchQueryOptions = function (_a) {
+        var _b;
+        if (_a === void 0) { _a = {}; }
+        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.displayName; var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "displayName"]);
+        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
+        if (skip) {
+            watchQueryOptions.fetchPolicy = 'standby';
         }
-        if (context$1.renderPromises &&
-            (options === null || options === void 0 ? void 0 : options.ssr) !== false &&
-            !(options === null || options === void 0 ? void 0 : options.skip) &&
-            obsQuery.getCurrentResult().loading) {
-            context$1.renderPromises.addQueryPromise({
-                getOptions: function () { return createWatchQueryOptions(query, options, defaultWatchQueryOptions); },
-                fetchData: function () { return new Promise(function (resolve) {
-                    var sub = obsQuery.subscribe({
-                        next: function (result) {
-                            if (!result.loading) {
+        else if (((_b = watchQueryOptions.context) === null || _b === void 0 ? void 0 : _b.renderPromises) &&
+            (watchQueryOptions.fetchPolicy === 'network-only' ||
+                watchQueryOptions.fetchPolicy === 'cache-and-network')) {
+            watchQueryOptions.fetchPolicy = 'cache-first';
+        }
+        else if (!watchQueryOptions.fetchPolicy) {
+            var defaultOptions = this.client.defaultOptions.watchQuery;
+            watchQueryOptions.fetchPolicy =
+                defaultOptions && defaultOptions.fetchPolicy || 'cache-first';
+        }
+        if (!watchQueryOptions.variables) {
+            watchQueryOptions.variables = {};
+        }
+        return watchQueryOptions;
+    };
+    InternalState.prototype.onCompleted = function (data) { };
+    InternalState.prototype.onError = function (error) { };
+    InternalState.prototype.useObservableQuery = function () {
+        var _this = this;
+        var obsQuery = this.observable =
+            this.renderPromises
+                && this.renderPromises.getSSRObservable(this.watchQueryOptions)
+                || this.observable
+                || this.client.watchQuery(this.watchQueryOptions);
+        this.obsQueryFields = react.useMemo(function () { return ({
+            refetch: obsQuery.refetch.bind(obsQuery),
+            fetchMore: obsQuery.fetchMore.bind(obsQuery),
+            updateQuery: obsQuery.updateQuery.bind(obsQuery),
+            startPolling: obsQuery.startPolling.bind(obsQuery),
+            stopPolling: obsQuery.stopPolling.bind(obsQuery),
+            subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
+        }); }, [obsQuery]);
+        if (this.renderPromises) {
+            this.renderPromises.registerSSRObservable(obsQuery);
+            if (!this.ssrDisabled && obsQuery.getCurrentResult().loading) {
+                this.renderPromises.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();
-                            }
-                        },
-                        error: function () {
-                            resolve();
-                            sub.unsubscribe();
-                        },
-                        complete: function () {
-                            resolve();
-                        },
-                    });
-                }); },
-            }, function () { return null; });
+                            },
+                            complete: function () {
+                                resolve();
+                            },
+                        });
+                    }); },
+                }, function () { return null; });
+                obsQuery.setOptions(this.watchQueryOptions).catch(function () { });
+            }
         }
+        var prevOptionsRef = react.useRef({
+            watchQueryOptions: this.watchQueryOptions,
+        });
+        react.useEffect(function () {
+            if (_this.renderPromises) ;
+            else if (_this.watchQueryOptions !== prevOptionsRef.current.watchQueryOptions) {
+                obsQuery.setOptions(_this.watchQueryOptions).catch(function () { });
+                prevOptionsRef.current.watchQueryOptions = _this.watchQueryOptions;
+                _this.setResult(obsQuery.getCurrentResult());
+            }
+        }, [obsQuery, this.watchQueryOptions]);
         return obsQuery;
-    }), obsQuery = _b[0], setObsQuery = _b[1];
-    var _c = react.useState(function () {
-        var _a, _b;
-        var result = obsQuery.getCurrentResult();
-        if (!result.loading && options) {
+    };
+    InternalState.prototype.useSubscriptionEffect = function (obsQuery) {
+        var _this = this;
+        react.useEffect(function () {
+            if (_this.renderPromises) {
+                return;
+            }
+            var onNext = function () {
+                var previousResult = _this.result;
+                var result = obsQuery.getCurrentResult();
+                if (previousResult &&
+                    previousResult.loading === result.loading &&
+                    previousResult.networkStatus === result.networkStatus &&
+                    equal.equal(previousResult.data, result.data)) {
+                    return;
+                }
+                _this.setResult(result);
+            };
+            var onError = function (error) {
+                var last = obsQuery["last"];
+                subscription.unsubscribe();
+                try {
+                    obsQuery.resetLastResults();
+                    subscription = obsQuery.subscribe(onNext, onError);
+                }
+                finally {
+                    obsQuery["last"] = last;
+                }
+                if (!hasOwnProperty.call(error, 'graphQLErrors')) {
+                    throw error;
+                }
+                var previousResult = _this.result;
+                if (!previousResult ||
+                    (previousResult && previousResult.loading) ||
+                    !equal.equal(error, previousResult.error)) {
+                    _this.setResult({
+                        data: (previousResult && previousResult.data),
+                        error: error,
+                        loading: false,
+                        networkStatus: core.NetworkStatus.error,
+                    });
+                }
+            };
+            var subscription = obsQuery.subscribe(onNext, onError);
+            return function () { return subscription.unsubscribe(); };
+        }, [
+            obsQuery,
+            this.renderPromises,
+            this.client.disableNetworkFetches,
+        ]);
+    };
+    InternalState.prototype.setResult = function (nextResult) {
+        var previousResult = this.result;
+        if (previousResult && previousResult.data) {
+            this.previousData = previousResult.data;
+        }
+        this.result = nextResult;
+        this.forceUpdate();
+        this.handleErrorOrCompleted(nextResult);
+    };
+    InternalState.prototype.handleErrorOrCompleted = function (result) {
+        if (!result.loading) {
             if (result.error) {
-                (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, result.error);
+                this.onError(result.error);
             }
             else if (result.data) {
-                (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, result.data);
+                this.onCompleted(result.data);
             }
         }
-        return result;
-    }), result = _c[0], setResult = _c[1];
-    var ref = react.useRef({
-        client: client,
-        query: query,
-        options: options,
-        result: result,
-        previousData: void 0,
-        watchQueryOptions: createWatchQueryOptions(query, options, defaultWatchQueryOptions),
-    });
-    react.useEffect(function () {
-        var _a, _b;
-        var watchQueryOptions = createWatchQueryOptions(query, options, defaultWatchQueryOptions);
-        var nextResult;
-        if (ref.current.client !== client || !equality.equal(ref.current.query, query)) {
-            var obsQuery_1 = client.watchQuery(watchQueryOptions);
-            setObsQuery(obsQuery_1);
-            nextResult = obsQuery_1.getCurrentResult();
+    };
+    InternalState.prototype.getCurrentResult = function () {
+        var result = this.result;
+        if (!result) {
+            result = this.result = this.observable.getCurrentResult();
+            this.handleErrorOrCompleted(result);
         }
-        else if (!equality.equal(ref.current.watchQueryOptions, watchQueryOptions)) {
-            obsQuery.setOptions(watchQueryOptions).catch(function () { });
-            nextResult = obsQuery.getCurrentResult();
-            ref.current.watchQueryOptions = watchQueryOptions;
-        }
-        if (nextResult) {
-            var previousResult = ref.current.result;
-            if (previousResult.data) {
-                ref.current.previousData = previousResult.data;
-            }
-            setResult(ref.current.result = nextResult);
-            if (!nextResult.loading && options) {
-                if (nextResult.error) {
-                    (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, nextResult.error);
-                }
-                else if (nextResult.data) {
-                    (_b = options.onCompleted) === null || _b === void 0 ? void 0 : _b.call(options, nextResult.data);
-                }
-            }
-        }
-        Object.assign(ref.current, { client: client, query: query });
-    }, [obsQuery, client, query, options]);
-    react.useEffect(function () {
-        if (context$1.renderPromises) {
-            return;
+        if ((this.renderPromises || this.client.disableNetworkFetches) &&
+            this.queryHookOptions.ssr === false) {
+            result = {
+                loading: true,
+                data: void 0,
+                error: void 0,
+                networkStatus: core.NetworkStatus.loading,
+            };
         }
-        var subscription = obsQuery.subscribe(onNext, onError);
-        function onNext() {
-            var _a, _b;
-            var previousResult = ref.current.result;
-            var result = obsQuery.getCurrentResult();
-            if (previousResult &&
-                previousResult.loading === result.loading &&
-                previousResult.networkStatus === result.networkStatus &&
-                equality.equal(previousResult.data, result.data)) {
-                return;
-            }
-            if (previousResult.data) {
-                ref.current.previousData = previousResult.data;
-            }
-            setResult(ref.current.result = result);
-            if (!result.loading) {
-                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, result.data);
-            }
+        else if (this.queryHookOptions.skip ||
+            this.queryHookOptions.fetchPolicy === 'standby') {
+            result = {
+                loading: false,
+                data: void 0,
+                error: void 0,
+                networkStatus: core.NetworkStatus.ready,
+            };
         }
-        function onError(error) {
-            var _a, _b;
-            var last = obsQuery["last"];
-            subscription.unsubscribe();
-            try {
-                obsQuery.resetLastResults();
-                subscription = obsQuery.subscribe(onNext, onError);
-            }
-            finally {
-                obsQuery["last"] = last;
-            }
-            if (!error.hasOwnProperty('graphQLErrors')) {
-                throw error;
-            }
-            var previousResult = ref.current.result;
-            if ((previousResult && previousResult.loading) ||
-                !equality.equal(error, previousResult.error)) {
-                setResult(ref.current.result = {
-                    data: previousResult.data,
-                    error: error,
-                    loading: false,
-                    networkStatus: core.NetworkStatus.error,
-                });
-                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-            }
+        return result;
+    };
+    InternalState.prototype.toQueryResult = function (result) {
+        var queryResult = this.toQueryResultCache.get(result);
+        if (queryResult)
+            return queryResult;
+        var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, ["data", "partial"]);
+        this.toQueryResultCache.set(result, queryResult = tslib.__assign(tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), this.obsQueryFields), { client: this.client, observable: this.observable, variables: this.observable.variables, called: true, previousData: this.previousData }));
+        if (!queryResult.error && utilities.isNonEmptyArray(result.errors)) {
+            queryResult.error = new errors.ApolloError({ graphQLErrors: result.errors });
         }
-        return function () { return subscription.unsubscribe(); };
-    }, [obsQuery, context$1.renderPromises, client.disableNetworkFetches]);
-    var partial;
-    (_a = result, partial = _a.partial, result = tslib.__rest(_a, ["partial"]));
-    {
-        if (partial &&
-            (options === null || options === void 0 ? void 0 : options.partialRefetch) &&
+        return queryResult;
+    };
+    InternalState.prototype.unsafeHandlePartialRefetch = function (result) {
+        if (result.partial &&
+            this.queryHookOptions.partialRefetch &&
             !result.loading &&
             (!result.data || Object.keys(result.data).length === 0) &&
-            obsQuery.options.fetchPolicy !== 'cache-only') {
-            result = tslib.__assign(tslib.__assign({}, result), { loading: true, networkStatus: core.NetworkStatus.refetch });
-            obsQuery.refetch();
-        }
-        if (context$1.renderPromises &&
-            (options === null || options === void 0 ? void 0 : options.ssr) !== false &&
-            !(options === null || options === void 0 ? void 0 : options.skip) &&
-            result.loading) {
-            obsQuery.setOptions(createWatchQueryOptions(query, options, defaultWatchQueryOptions)).catch(function () { });
+            this.observable.options.fetchPolicy !== 'cache-only') {
+            Object.assign(result, {
+                loading: true,
+                networkStatus: core.NetworkStatus.refetch,
+            });
+            this.observable.refetch();
         }
-        Object.assign(ref.current, { options: options });
-    }
-    if ((context$1.renderPromises || client.disableNetworkFetches) &&
-        (options === null || options === void 0 ? void 0 : options.ssr) === false) {
-        result = ref.current.result = {
-            loading: true,
-            data: void 0,
-            error: void 0,
-            networkStatus: core.NetworkStatus.loading,
-        };
-    }
-    else if ((options === null || options === void 0 ? void 0 : options.skip) || (options === null || options === void 0 ? void 0 : options.fetchPolicy) === 'standby') {
-        result = {
-            loading: false,
-            data: void 0,
-            error: void 0,
-            networkStatus: core.NetworkStatus.ready,
-        };
-    }
-    if (result.errors && result.errors.length) {
-        result = tslib.__assign(tslib.__assign({}, result), { error: result.error || new errors.ApolloError({ graphQLErrors: result.errors }) });
-    }
-    var obsQueryFields = react.useMemo(function () { return ({
-        refetch: obsQuery.refetch.bind(obsQuery),
-        fetchMore: obsQuery.fetchMore.bind(obsQuery),
-        updateQuery: obsQuery.updateQuery.bind(obsQuery),
-        startPolling: obsQuery.startPolling.bind(obsQuery),
-        stopPolling: obsQuery.stopPolling.bind(obsQuery),
-        subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),
-    }); }, [obsQuery]);
-    return tslib.__assign(tslib.__assign(tslib.__assign({}, obsQueryFields), { variables: createWatchQueryOptions(query, options, defaultWatchQueryOptions).variables, client: client, called: true, previousData: ref.current.previousData }), result);
-}
-function createWatchQueryOptions(query, options, defaultOptions) {
-    var _a;
-    if (options === void 0) { options = {}; }
-    var skip = options.skip; options.ssr; options.onCompleted; options.onError; options.displayName; var otherOptions = tslib.__rest(options, ["skip", "ssr", "onCompleted", "onError", "displayName"]);
-    var watchQueryOptions = tslib.__assign({ query: query }, otherOptions);
-    if (defaultOptions) {
-        watchQueryOptions = core.mergeOptions(defaultOptions, watchQueryOptions);
-    }
-    if (skip) {
-        watchQueryOptions.fetchPolicy = 'standby';
-    }
-    else if (((_a = watchQueryOptions.context) === null || _a === void 0 ? void 0 : _a.renderPromises) &&
-        (watchQueryOptions.fetchPolicy === 'network-only' ||
-            watchQueryOptions.fetchPolicy === 'cache-and-network')) {
-        watchQueryOptions.fetchPolicy = 'cache-first';
-    }
-    else if (!watchQueryOptions.fetchPolicy) {
-        watchQueryOptions.fetchPolicy = 'cache-first';
-    }
-    if (!watchQueryOptions.variables) {
-        watchQueryOptions.variables = {};
-    }
-    return watchQueryOptions;
-}
+    };
+    return InternalState;
+}());
 
 var EAGER_METHODS = [
     'refetch',
@@ -249,7 +301,8 @@ var EAGER_METHODS = [
     'startPolling',
     'subscribeToMore',
 ];
-function useLazyQuery(query, options) {
+function useLazyQuery(query, optionsOrFunction) {
+    var options = useNormalizedOptions(optionsOrFunction);
     var _a = react.useState({
         called: false,
     }), execution = _a[0], setExecution = _a[1];
@@ -340,7 +393,7 @@ function useMutation(mutation, options) {
                     error: error,
                     client: client,
                 };
-                if (ref.current.isMounted && !equality.equal(ref.current.result, result_1)) {
+                if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {
                     setResult(ref.current.result = result_1);
                 }
             }
@@ -358,7 +411,7 @@ function useMutation(mutation, options) {
                     called: true,
                     client: client,
                 };
-                if (!equality.equal(ref.current.result, result_2)) {
+                if (!equal.equal(ref.current.result, result_2)) {
                     setResult(ref.current.result = result_2);
                 }
             }
@@ -421,7 +474,7 @@ function useSubscription(subscription, options) {
             subscription !== ref.current.subscription ||
             (options === null || options === void 0 ? void 0 : options.fetchPolicy) !== ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
             !(options === null || options === void 0 ? void 0 : options.skip) !== !((_c = ref.current.options) === null || _c === void 0 ? void 0 : _c.skip) ||
-            !equality.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) {
+            !equal.equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) {
             setResult({
                 loading: true,
                 data: void 0,