You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
5.5 KiB
131 lines
5.5 KiB
import { __assign, __spreadArray } from "tslib"; |
|
import * as React from "rehackt"; |
|
import { invariant } from "../../utilities/globals/index.js"; |
|
import { ApolloError, NetworkStatus } from "../../core/index.js"; |
|
import { isNonEmptyArray } from "../../utilities/index.js"; |
|
import { useApolloClient } from "./useApolloClient.js"; |
|
import { DocumentType, verifyDocumentType } from "../parser/index.js"; |
|
import { __use, useDeepMemo } from "./internal/index.js"; |
|
import { getSuspenseCache } from "../internal/index.js"; |
|
import { canonicalStringify } from "../../cache/index.js"; |
|
import { skipToken } from "./constants.js"; |
|
export function useSuspenseQuery(query, options) { |
|
if (options === void 0) { options = Object.create(null); } |
|
var client = useApolloClient(options.client); |
|
var suspenseCache = getSuspenseCache(client); |
|
var watchQueryOptions = useWatchQueryOptions({ |
|
client: client, |
|
query: query, |
|
options: options, |
|
}); |
|
var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables; |
|
var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a; |
|
var cacheKey = __spreadArray([ |
|
query, |
|
canonicalStringify(variables) |
|
], [].concat(queryKey), true); |
|
var queryRef = suspenseCache.getQueryRef(cacheKey, function () { |
|
return client.watchQuery(watchQueryOptions); |
|
}); |
|
var _b = React.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1]; |
|
// This saves us a re-execution of the render function when a variable changed. |
|
if (current[0] !== queryRef.key) { |
|
current[0] = queryRef.key; |
|
current[1] = queryRef.promise; |
|
} |
|
var promise = current[1]; |
|
if (queryRef.didChangeOptions(watchQueryOptions)) { |
|
current[1] = promise = queryRef.applyOptions(watchQueryOptions); |
|
} |
|
React.useEffect(function () { |
|
var dispose = queryRef.retain(); |
|
var removeListener = queryRef.listen(function (promise) { |
|
setPromise([queryRef.key, promise]); |
|
}); |
|
return function () { |
|
removeListener(); |
|
dispose(); |
|
}; |
|
}, [queryRef]); |
|
var skipResult = React.useMemo(function () { |
|
var error = toApolloError(queryRef.result); |
|
return { |
|
loading: false, |
|
data: queryRef.result.data, |
|
networkStatus: error ? NetworkStatus.error : NetworkStatus.ready, |
|
error: error, |
|
}; |
|
}, [queryRef.result]); |
|
var result = fetchPolicy === "standby" ? skipResult : __use(promise); |
|
var fetchMore = React.useCallback((function (options) { |
|
var promise = queryRef.fetchMore(options); |
|
setPromise([queryRef.key, queryRef.promise]); |
|
return promise; |
|
}), [queryRef]); |
|
var refetch = React.useCallback(function (variables) { |
|
var promise = queryRef.refetch(variables); |
|
setPromise([queryRef.key, queryRef.promise]); |
|
return promise; |
|
}, [queryRef]); |
|
var subscribeToMore = React.useCallback(function (options) { return queryRef.observable.subscribeToMore(options); }, [queryRef]); |
|
return React.useMemo(function () { |
|
return { |
|
client: client, |
|
data: result.data, |
|
error: toApolloError(result), |
|
networkStatus: result.networkStatus, |
|
fetchMore: fetchMore, |
|
refetch: refetch, |
|
subscribeToMore: subscribeToMore, |
|
}; |
|
}, [client, fetchMore, refetch, result, subscribeToMore]); |
|
} |
|
function validateOptions(options) { |
|
var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData; |
|
verifyDocumentType(query, DocumentType.Query); |
|
validateFetchPolicy(fetchPolicy); |
|
validatePartialDataReturn(fetchPolicy, returnPartialData); |
|
} |
|
function validateFetchPolicy(fetchPolicy) { |
|
if (fetchPolicy === void 0) { fetchPolicy = "cache-first"; } |
|
var supportedFetchPolicies = [ |
|
"cache-first", |
|
"network-only", |
|
"no-cache", |
|
"cache-and-network", |
|
]; |
|
invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy); |
|
} |
|
function validatePartialDataReturn(fetchPolicy, returnPartialData) { |
|
if (fetchPolicy === "no-cache" && returnPartialData) { |
|
globalThis.__DEV__ !== false && invariant.warn(57); |
|
} |
|
} |
|
export function toApolloError(result) { |
|
return isNonEmptyArray(result.errors) ? |
|
new ApolloError({ graphQLErrors: result.errors }) |
|
: result.error; |
|
} |
|
export function useWatchQueryOptions(_a) { |
|
var client = _a.client, query = _a.query, options = _a.options; |
|
return useDeepMemo(function () { |
|
var _a; |
|
if (options === skipToken) { |
|
return { query: query, fetchPolicy: "standby" }; |
|
} |
|
var fetchPolicy = options.fetchPolicy || |
|
((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) || |
|
"cache-first"; |
|
var watchQueryOptions = __assign(__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 }); |
|
if (globalThis.__DEV__ !== false) { |
|
validateOptions(watchQueryOptions); |
|
} |
|
// Assign the updated fetch policy after our validation since `standby` is |
|
// not a supported fetch policy on its own without the use of `skip`. |
|
if (options.skip) { |
|
watchQueryOptions.fetchPolicy = "standby"; |
|
} |
|
return watchQueryOptions; |
|
}, [client, options, query]); |
|
} |
|
//# sourceMappingURL=useSuspenseQuery.js.map
|