@apollo/client 3.6.1 → 3.6.4

package/react/hooks/hooks.cjs.native.js

@@ -0,0 +1,604 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+var React = require('react');
+var context = require('../context');
+var tslib = require('tslib');
+var utilities = require('../../utilities');
+var equality = require('@wry/equality');
+var core = require('../../core');
+var errors = require('../../errors');
+var parser = require('../parser');
+
+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 useApolloClient(override) {
+    var context$1 = React.useContext(context.getApolloContext());
+    var client = override || context$1.client;
+    __DEV__ ? globals.invariant(!!client, 'Could not find "client" in the context or passed in as an option. ' +
+        'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient ' +
+        'instance in via options.') : globals.invariant(!!client, 29);
+    return client;
+}
+
+var didWarnUncachedGetSnapshot = false;
+var uSESKey = "useSyncExternalStore";
+var realHook = React__namespace[uSESKey];
+var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {
+    var value = getSnapshot();
+    if (__DEV__ &&
+        !didWarnUncachedGetSnapshot &&
+        value !== getSnapshot()) {
+        didWarnUncachedGetSnapshot = true;
+        __DEV__ && globals.invariant.error('The result of getSnapshot should be cached to avoid an infinite loop');
+    }
+    var _a = React__namespace.useState({ inst: { value: value, getSnapshot: getSnapshot } }), inst = _a[0].inst, forceUpdate = _a[1];
+    if (utilities.canUseLayoutEffect) {
+        React__namespace.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__namespace.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;
+    }
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function useQuery(query, options) {
+    if (options === void 0) { options = Object.create(null); }
+    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.asyncResolveFns = new Set();
+        this.optionsToIgnoreOnce = new (utilities.canUseWeakSet ? WeakSet : Set)();
+        this.ssrDisabledResult = utilities.maybeDeepFreeze({
+            loading: true,
+            data: void 0,
+            error: void 0,
+            networkStatus: core.NetworkStatus.loading,
+        });
+        this.skipStandbyResult = utilities.maybeDeepFreeze({
+            loading: false,
+            data: void 0,
+            error: void 0,
+            networkStatus: core.NetworkStatus.ready,
+        });
+        this.toQueryResultCache = new (utilities.canUseWeakMap ? WeakMap : Map)();
+        parser.verifyDocumentType(query, parser.DocumentType.Query);
+    }
+    InternalState.prototype.forceUpdate = function () {
+        __DEV__ && globals.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
+    };
+    InternalState.prototype.asyncUpdate = function () {
+        var _this = this;
+        return new Promise(function (resolve) {
+            _this.asyncResolveFns.add(resolve);
+            _this.optionsToIgnoreOnce.add(_this.watchQueryOptions);
+            _this.forceUpdate();
+        });
+    };
+    InternalState.prototype.useQuery = function (options) {
+        var _this = this;
+        this.renderPromises = React.useContext(context.getApolloContext()).renderPromises;
+        this.useOptions(options);
+        var obsQuery = this.useObservableQuery();
+        var result = useSyncExternalStore(React.useCallback(function () {
+            if (_this.renderPromises) {
+                return function () { };
+            }
+            var onNext = function () {
+                var previousResult = _this.result;
+                var result = obsQuery.getCurrentResult();
+                if (previousResult &&
+                    previousResult.loading === result.loading &&
+                    previousResult.networkStatus === result.networkStatus &&
+                    equality.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) ||
+                    !equality.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,
+        ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });
+        this.unsafeHandlePartialRefetch(result);
+        var queryResult = this.toQueryResult(result);
+        if (!queryResult.loading && this.asyncResolveFns.size) {
+            this.asyncResolveFns.forEach(function (resolve) { return resolve(queryResult); });
+            this.asyncResolveFns.clear();
+        }
+        return queryResult;
+    };
+    InternalState.prototype.useOptions = function (options) {
+        var _a;
+        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);
+        var currentWatchQueryOptions = this.watchQueryOptions;
+        if (this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||
+            !equality.equal(watchQueryOptions, currentWatchQueryOptions)) {
+            this.watchQueryOptions = watchQueryOptions;
+            if (currentWatchQueryOptions && this.observable) {
+                this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);
+                this.observable.reobserve(watchQueryOptions);
+                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;
+                this.result = void 0;
+            }
+        }
+        this.onCompleted = options.onCompleted || InternalState.prototype.onCompleted;
+        this.onError = options.onError || InternalState.prototype.onError;
+        if ((this.renderPromises || this.client.disableNetworkFetches) &&
+            this.queryHookOptions.ssr === false &&
+            !this.queryHookOptions.skip) {
+            this.result = this.ssrDisabledResult;
+        }
+        else if (this.queryHookOptions.skip ||
+            this.watchQueryOptions.fetchPolicy === 'standby') {
+            this.result = this.skipStandbyResult;
+        }
+        else if (this.result === this.ssrDisabledResult ||
+            this.result === this.skipStandbyResult) {
+            this.result = void 0;
+        }
+    };
+    InternalState.prototype.createWatchQueryOptions = function (_a) {
+        var _b;
+        if (_a === void 0) { _a = {}; }
+        var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.displayName; _a.defaultOptions; var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "displayName", "defaultOptions"]);
+        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });
+        if (this.renderPromises &&
+            (watchQueryOptions.fetchPolicy === 'network-only' ||
+                watchQueryOptions.fetchPolicy === 'cache-and-network')) {
+            watchQueryOptions.fetchPolicy = 'cache-first';
+        }
+        if (!watchQueryOptions.variables) {
+            watchQueryOptions.variables = {};
+        }
+        if (skip) {
+            var _c = watchQueryOptions.fetchPolicy, fetchPolicy = _c === void 0 ? this.getDefaultFetchPolicy() : _c, _d = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _d === void 0 ? fetchPolicy : _d;
+            Object.assign(watchQueryOptions, {
+                initialFetchPolicy: initialFetchPolicy,
+                fetchPolicy: 'standby',
+            });
+        }
+        else if (!watchQueryOptions.fetchPolicy) {
+            watchQueryOptions.fetchPolicy =
+                ((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||
+                    this.getDefaultFetchPolicy();
+        }
+        return watchQueryOptions;
+    };
+    InternalState.prototype.getDefaultFetchPolicy = function () {
+        var _a, _b;
+        return (((_a = this.queryHookOptions.defaultOptions) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||
+            ((_b = this.client.defaultOptions.watchQuery) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||
+            "cache-first");
+    };
+    InternalState.prototype.onCompleted = function (data) { };
+    InternalState.prototype.onError = function (error) { };
+    InternalState.prototype.useObservableQuery = function () {
+        var obsQuery = this.observable =
+            this.renderPromises
+                && this.renderPromises.getSSRObservable(this.watchQueryOptions)
+                || this.observable
+                || this.client.watchQuery(core.mergeOptions(this.queryHookOptions.defaultOptions, this.watchQueryOptions));
+        this.obsQueryFields = React.useMemo(function () { return ({
+            refetch: obsQuery.refetch.bind(obsQuery),
+            reobserve: obsQuery.reobserve.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]);
+        var ssrAllowed = !(this.queryHookOptions.ssr === false ||
+            this.queryHookOptions.skip);
+        if (this.renderPromises && ssrAllowed) {
+            this.renderPromises.registerSSRObservable(obsQuery);
+            if (obsQuery.getCurrentResult().loading) {
+                this.renderPromises.addObservableQueryPromise(obsQuery);
+            }
+        }
+        return obsQuery;
+    };
+    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) {
+                this.onError(result.error);
+            }
+            else if (result.data) {
+                this.onCompleted(result.data);
+            }
+        }
+    };
+    InternalState.prototype.getCurrentResult = function () {
+        if (!this.result) {
+            this.handleErrorOrCompleted(this.result = this.observable.getCurrentResult());
+        }
+        return this.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 queryResult;
+    };
+    InternalState.prototype.unsafeHandlePartialRefetch = function (result) {
+        if (result.partial &&
+            this.queryHookOptions.partialRefetch &&
+            !result.loading &&
+            (!result.data || Object.keys(result.data).length === 0) &&
+            this.observable.options.fetchPolicy !== 'cache-only') {
+            Object.assign(result, {
+                loading: true,
+                networkStatus: core.NetworkStatus.refetch,
+            });
+            this.observable.refetch();
+        }
+    };
+    return InternalState;
+}());
+
+var EAGER_METHODS = [
+    'refetch',
+    'reobserve',
+    'fetchMore',
+    'updateQuery',
+    'startPolling',
+    'subscribeToMore',
+];
+function useLazyQuery(query, options) {
+    var internalState = useInternalState(useApolloClient(options && options.client), query);
+    var execOptionsRef = React.useRef();
+    var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign(tslib.__assign({}, options), execOptionsRef.current), { skip: !execOptionsRef.current }));
+    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
+        internalState.getDefaultFetchPolicy();
+    var result = Object.assign(useQueryResult, {
+        called: !!execOptionsRef.current,
+    });
+    var eagerMethods = React.useMemo(function () {
+        var eagerMethods = {};
+        var _loop_1 = function (key) {
+            var method = result[key];
+            eagerMethods[key] = function () {
+                if (!execOptionsRef.current) {
+                    execOptionsRef.current = Object.create(null);
+                    internalState.forceUpdate();
+                }
+                return method.apply(this, arguments);
+            };
+        };
+        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {
+            var key = EAGER_METHODS_1[_i];
+            _loop_1(key);
+        }
+        return eagerMethods;
+    }, []);
+    Object.assign(result, eagerMethods);
+    var execute = React.useCallback(function (executeOptions) {
+        execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
+            fetchPolicy: initialFetchPolicy,
+        };
+        var promise = internalState
+            .asyncUpdate()
+            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
+        promise.catch(function () { });
+        return promise;
+    }, []);
+    return [execute, result];
+}
+
+function useMutation(mutation, options) {
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    parser.verifyDocumentType(mutation, parser.DocumentType.Mutation);
+    var _a = React.useState({
+        called: false,
+        loading: false,
+        client: client,
+    }), result = _a[0], setResult = _a[1];
+    var ref = React.useRef({
+        result: result,
+        mutationId: 0,
+        isMounted: true,
+        client: client,
+        mutation: mutation,
+        options: options,
+    });
+    {
+        Object.assign(ref.current, { client: client, options: options, mutation: mutation });
+    }
+    var execute = React.useCallback(function (executeOptions) {
+        if (executeOptions === void 0) { executeOptions = {}; }
+        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;
+        var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
+        if (!ref.current.result.loading && !baseOptions.ignoreResults) {
+            setResult(ref.current.result = {
+                loading: true,
+                error: void 0,
+                data: void 0,
+                called: true,
+                client: client,
+            });
+        }
+        var mutationId = ++ref.current.mutationId;
+        var clientOptions = core.mergeOptions(baseOptions, executeOptions);
+        return client.mutate(clientOptions).then(function (response) {
+            var _a, _b;
+            var data = response.data, errors$1 = response.errors;
+            var error = errors$1 && errors$1.length > 0
+                ? new errors.ApolloError({ graphQLErrors: errors$1 })
+                : void 0;
+            if (mutationId === ref.current.mutationId &&
+                !clientOptions.ignoreResults) {
+                var result_1 = {
+                    called: true,
+                    loading: false,
+                    data: data,
+                    error: error,
+                    client: client,
+                };
+                if (ref.current.isMounted && !equality.equal(ref.current.result, result_1)) {
+                    setResult(ref.current.result = result_1);
+                }
+            }
+            (_a = baseOptions.onCompleted) === null || _a === void 0 ? void 0 : _a.call(baseOptions, response.data);
+            (_b = executeOptions.onCompleted) === null || _b === void 0 ? void 0 : _b.call(executeOptions, response.data);
+            return response;
+        }).catch(function (error) {
+            var _a, _b;
+            if (mutationId === ref.current.mutationId &&
+                ref.current.isMounted) {
+                var result_2 = {
+                    loading: false,
+                    error: error,
+                    data: void 0,
+                    called: true,
+                    client: client,
+                };
+                if (!equality.equal(ref.current.result, result_2)) {
+                    setResult(ref.current.result = result_2);
+                }
+            }
+            if (baseOptions.onError || clientOptions.onError) {
+                (_a = baseOptions.onError) === null || _a === void 0 ? void 0 : _a.call(baseOptions, error);
+                (_b = executeOptions.onError) === null || _b === void 0 ? void 0 : _b.call(executeOptions, error);
+                return { data: void 0, errors: error };
+            }
+            throw error;
+        });
+    }, []);
+    var reset = React.useCallback(function () {
+        setResult({ called: false, loading: false, client: client });
+    }, []);
+    React.useEffect(function () {
+        ref.current.isMounted = true;
+        return function () {
+            ref.current.isMounted = false;
+        };
+    }, []);
+    return [execute, tslib.__assign({ reset: reset }, result)];
+}
+
+function useSubscription(subscription, options) {
+    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);
+    parser.verifyDocumentType(subscription, parser.DocumentType.Subscription);
+    var _a = React.useState({
+        loading: !(options === null || options === void 0 ? void 0 : options.skip),
+        error: void 0,
+        data: void 0,
+        variables: options === null || options === void 0 ? void 0 : options.variables,
+    }), result = _a[0], setResult = _a[1];
+    var _b = React.useState(function () {
+        if (options === null || options === void 0 ? void 0 : options.skip) {
+            return null;
+        }
+        return client.subscribe({
+            query: subscription,
+            variables: options === null || options === void 0 ? void 0 : options.variables,
+            fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+            context: options === null || options === void 0 ? void 0 : options.context,
+        });
+    }), observable = _b[0], setObservable = _b[1];
+    var canResetObservableRef = React.useRef(false);
+    React.useEffect(function () {
+        return function () {
+            canResetObservableRef.current = true;
+        };
+    }, []);
+    var ref = React.useRef({ client: client, subscription: subscription, options: options });
+    React.useEffect(function () {
+        var _a, _b, _c, _d;
+        var shouldResubscribe = options === null || options === void 0 ? void 0 : options.shouldResubscribe;
+        if (typeof shouldResubscribe === 'function') {
+            shouldResubscribe = !!shouldResubscribe(options);
+        }
+        if (options === null || options === void 0 ? void 0 : options.skip) {
+            if (!(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip) || canResetObservableRef.current) {
+                setResult({
+                    loading: false,
+                    data: void 0,
+                    error: void 0,
+                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                });
+                setObservable(null);
+                canResetObservableRef.current = false;
+            }
+        }
+        else if ((shouldResubscribe !== false &&
+            (client !== ref.current.client ||
+                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))) ||
+            canResetObservableRef.current) {
+            setResult({
+                loading: true,
+                data: void 0,
+                error: void 0,
+                variables: options === null || options === void 0 ? void 0 : options.variables,
+            });
+            setObservable(client.subscribe({
+                query: subscription,
+                variables: options === null || options === void 0 ? void 0 : options.variables,
+                fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+                context: options === null || options === void 0 ? void 0 : options.context,
+            }));
+            canResetObservableRef.current = false;
+        }
+        Object.assign(ref.current, { client: client, subscription: subscription, options: options });
+    }, [client, subscription, options, canResetObservableRef.current]);
+    React.useEffect(function () {
+        if (!observable) {
+            return;
+        }
+        var subscription = observable.subscribe({
+            next: function (fetchResult) {
+                var _a, _b;
+                var result = {
+                    loading: false,
+                    data: fetchResult.data,
+                    error: void 0,
+                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                };
+                setResult(result);
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onSubscriptionData) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                    client: client,
+                    subscriptionData: result
+                });
+            },
+            error: function (error) {
+                setResult({
+                    loading: false,
+                    data: void 0,
+                    error: error,
+                    variables: options === null || options === void 0 ? void 0 : options.variables,
+                });
+            },
+            complete: function () {
+                var _a, _b;
+                (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onSubscriptionComplete) === null || _b === void 0 ? void 0 : _b.call(_a);
+            },
+        });
+        return function () {
+            subscription.unsubscribe();
+        };
+    }, [observable]);
+    return result;
+}
+
+function useReactiveVar(rv) {
+    var value = rv();
+    var setValue = React.useState(value)[1];
+    React.useEffect(function () {
+        var probablySameValue = rv();
+        if (value !== probablySameValue) {
+            setValue(probablySameValue);
+        }
+        else {
+            return rv.onNextChange(setValue);
+        }
+    }, [value]);
+    return value;
+}
+
+exports.useApolloClient = useApolloClient;
+exports.useLazyQuery = useLazyQuery;
+exports.useMutation = useMutation;
+exports.useQuery = useQuery;
+exports.useReactiveVar = useReactiveVar;
+exports.useSubscription = useSubscription;
+//# sourceMappingURL=hooks.cjs.map

package/react/hooks/useLazyQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyQuery.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useLazyQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAGtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,gBAAgB,CAAC;AAgBxB,wBAAgB,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,kBAAkB,EACvE,KAAK,EAAE,YAAY,GAAG,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC,EAC1D,OAAO,CAAC,EAAE,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,GAChD,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,CA6FzC"}
+{"version":3,"file":"useLazyQuery.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useLazyQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAGtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,gBAAgB,CAAC;AAexB,wBAAgB,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,kBAAkB,EACvE,KAAK,EAAE,YAAY,GAAG,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC,EAC1D,OAAO,CAAC,EAAE,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,GAChD,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,CAiEzC"}

package/react/hooks/useLazyQuery.js

@@ -1,9 +1,7 @@
 import { __assign } from "tslib";
 import { useCallback, useMemo, useRef } from 'react';
-import { ApolloError } from "../../errors/index.js";
 import { useInternalState } from "./useQuery.js";
 import { useApolloClient } from "./useApolloClient.js";
-import { isNonEmptyArray } from "../../utilities/index.js";
 var EAGER_METHODS = [
     'refetch',
     'reobserve',
@@ -15,12 +13,9 @@ var EAGER_METHODS = [
 export function useLazyQuery(query, options) {
     var internalState = useInternalState(useApolloClient(options && options.client), query);
     var execOptionsRef = useRef();
-    var defaultOptions = internalState.client.defaultOptions.watchQuery;
-    var initialFetchPolicy = (options && options.fetchPolicy) ||
-        (execOptionsRef.current && execOptionsRef.current.fetchPolicy) ||
-        (defaultOptions && defaultOptions.fetchPolicy) ||
-        "cache-first";
     var useQueryResult = internalState.useQuery(__assign(__assign(__assign({}, options), execOptionsRef.current), { skip: !execOptionsRef.current }));
+    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||
+        internalState.getDefaultFetchPolicy();
     var result = Object.assign(useQueryResult, {
         called: !!execOptionsRef.current,
     });
@@ -44,22 +39,12 @@ export function useLazyQuery(query, options) {
     }, []);
     Object.assign(result, eagerMethods);
     var execute = useCallback(function (executeOptions) {
-        var promise = result.reobserve(execOptionsRef.current = executeOptions ? __assign(__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
+        execOptionsRef.current = executeOptions ? __assign(__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
             fetchPolicy: initialFetchPolicy,
-        }).then(function (apolloQueryResult) {
-            apolloQueryResult = apolloQueryResult || internalState["getCurrentResult"]();
-            if (apolloQueryResult.error ||
-                isNonEmptyArray(apolloQueryResult.errors)) {
-                var _a = result.observable.options.errorPolicy, errorPolicy = _a === void 0 ? "none" : _a;
-                if (errorPolicy === "none") {
-                    throw apolloQueryResult.error || new ApolloError({
-                        graphQLErrors: apolloQueryResult.errors,
-                    });
-                }
-            }
-            return internalState.toQueryResult(apolloQueryResult);
-        }).then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
-        internalState.forceUpdate();
+        };
+        var promise = internalState
+            .asyncUpdate()
+            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });
         promise.catch(function () { });
         return promise;
     }, []);