@apollo/client
Version:
A fully-featured caching GraphQL client.
723 lines (709 loc) • 32.2 kB
JavaScript
'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, 32);
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, stateRef.current);
}
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, previous) {
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);
var previousResult = previous && previous.result;
var previousData = previousResult && previousResult.data;
if (previousData) {
this.previousData = previousData;
}
}
InternalState.prototype.forceUpdate = function () {
__DEV__ && globals.invariant.warn("Calling default no-op implementation of InternalState#forceUpdate");
};
InternalState.prototype.asyncUpdate = function (signal) {
var _this = this;
return new Promise(function (resolve, reject) {
var watchQueryOptions = _this.watchQueryOptions;
var handleAborted = function () {
_this.asyncResolveFns.delete(resolve);
_this.optionsToIgnoreOnce.delete(watchQueryOptions);
signal.removeEventListener('abort', handleAborted);
reject(signal.reason);
};
_this.asyncResolveFns.add(resolve);
_this.optionsToIgnoreOnce.add(watchQueryOptions);
signal.addEventListener('abort', handleAborted);
_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(this.getObsQueryOptions());
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.getObsQueryOptions = function () {
var toMerge = [];
var globalDefaults = this.client.defaultOptions.watchQuery;
if (globalDefaults)
toMerge.push(globalDefaults);
if (this.queryHookOptions.defaultOptions) {
toMerge.push(this.queryHookOptions.defaultOptions);
}
toMerge.push(utilities.compact(this.observable && this.observable.options, this.watchQueryOptions));
return toMerge.reduce(core.mergeOptions);
};
InternalState.prototype.createWatchQueryOptions = function (_a) {
var _b;
if (_a === void 0) { _a = {}; }
var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; _a.defaultOptions; var otherOptions = tslib.__rest(_a, ["skip", "ssr", "onCompleted", "onError", "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(this.getObsQueryOptions());
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) {
var _this = this;
if (!result.loading) {
var error_1 = this.toApolloError(result);
Promise.resolve().then(function () {
if (error_1) {
_this.onError(error_1);
}
else if (result.data) {
_this.onCompleted(result.data);
}
}).catch(function (error) {
__DEV__ && globals.invariant.warn(error);
});
}
};
InternalState.prototype.toApolloError = function (result) {
return utilities.isNonEmptyArray(result.errors)
? new errors.ApolloError({ graphQLErrors: result.errors })
: result.error;
};
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: !this.queryHookOptions.skip, 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 _a;
var abortControllersRef = React.useRef(new Set());
var execOptionsRef = React.useRef();
var merged = execOptionsRef.current ? utilities.mergeOptions(options, execOptionsRef.current) : options;
var internalState = useInternalState(useApolloClient(options && options.client), (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query);
var useQueryResult = internalState.useQuery(tslib.__assign(tslib.__assign({}, merged), { 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);
React.useEffect(function () {
return function () {
abortControllersRef.current.forEach(function (controller) {
controller.abort();
});
};
}, []);
var execute = React.useCallback(function (executeOptions) {
var controller = new AbortController();
abortControllersRef.current.add(controller);
execOptionsRef.current = executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {
fetchPolicy: initialFetchPolicy,
};
var promise = internalState
.asyncUpdate(controller.signal)
.then(function (queryResult) {
abortControllersRef.current.delete(controller);
return Object.assign(queryResult, eagerMethods);
});
promise.catch(function () {
abortControllersRef.current.delete(controller);
});
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, options = _a.options, mutation = _a.mutation;
var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });
var client = executeOptions.client || ref.current.client;
if (!ref.current.result.loading && !baseOptions.ignoreResults && ref.current.isMounted) {
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;
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);
}
}
var onCompleted = executeOptions.onCompleted || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted);
onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);
return response;
}).catch(function (error) {
var _a;
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);
}
}
var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);
if (onError) {
onError(error, clientOptions);
return { data: void 0, errors: error };
}
throw error;
});
}, []);
var reset = React.useCallback(function () {
if (ref.current.isMounted) {
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 hasIssuedDeprecationWarningRef = React.useRef(false);
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];
if (!hasIssuedDeprecationWarningRef.current) {
hasIssuedDeprecationWarningRef.current = true;
if (options === null || options === void 0 ? void 0 : options.onSubscriptionData) {
__DEV__ && globals.invariant.warn(options.onData
? "'useSubscription' supports only the 'onSubscriptionData' or 'onData' option, but not both. Only the 'onData' option will be used."
: "'onSubscriptionData' is deprecated and will be removed in a future major version. Please use the 'onData' option instead.");
}
if (options === null || options === void 0 ? void 0 : options.onSubscriptionComplete) {
__DEV__ && globals.invariant.warn(options.onComplete
? "'useSubscription' supports only the 'onSubscriptionComplete' or 'onComplete' option, but not both. Only the 'onComplete' option will be used."
: "'onSubscriptionComplete' is deprecated and will be removed in a future major version. Please use the 'onComplete' option instead.");
}
}
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);
if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onData) {
ref.current.options.onData({
client: client,
data: result
});
}
else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionData) {
ref.current.options.onSubscriptionData({
client: client,
subscriptionData: result
});
}
},
error: function (error) {
var _a, _b;
setResult({
loading: false,
data: void 0,
error: error,
variables: options === null || options === void 0 ? void 0 : options.variables,
});
(_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
},
complete: function () {
var _a, _b;
if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onComplete) {
ref.current.options.onComplete();
}
else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionComplete) {
ref.current.options.onSubscriptionComplete();
}
},
});
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;
}
function useFragment_experimental(options) {
var cache = useApolloClient().cache;
var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, rest = tslib.__rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
var diffOptions = tslib.__assign(tslib.__assign({}, rest), { id: typeof from === "string" ? from : cache.identify(from), query: cache["getFragmentDoc"](fragment, fragmentName), optimistic: optimistic });
var resultRef = React.useRef();
var latestDiff = cache.diff(diffOptions);
var getSnapshot = function () {
var latestDiffToResult = diffToResult(latestDiff);
return resultRef.current &&
equality.equal(resultRef.current.data, latestDiffToResult.data)
? resultRef.current
: (resultRef.current = latestDiffToResult);
};
return useSyncExternalStore(function (forceUpdate) {
return cache.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {
if (!equality.equal(diff, latestDiff)) {
resultRef.current = diffToResult((latestDiff = diff));
forceUpdate();
}
} }));
}, getSnapshot, getSnapshot);
}
function diffToResult(diff) {
var result = {
data: diff.result,
complete: !!diff.complete,
};
if (diff.missing) {
result.missing = utilities.mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));
}
return result;
}
exports.useApolloClient = useApolloClient;
exports.useFragment_experimental = useFragment_experimental;
exports.useLazyQuery = useLazyQuery;
exports.useMutation = useMutation;
exports.useQuery = useQuery;
exports.useReactiveVar = useReactiveVar;
exports.useSubscription = useSubscription;
//# sourceMappingURL=hooks.cjs.map