@tanstack/query-core
Version:
The framework agnostic core that powers TanStack Query
325 lines (324 loc) • 12.4 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __accessCheck = (obj, member, msg) => {
if (!member.has(obj))
throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
__accessCheck(obj, member, "read from private field");
return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
if (member.has(obj))
throw TypeError("Cannot add the same private member more than once");
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var __privateSet = (obj, member, value, setter) => {
__accessCheck(obj, member, "write to private field");
setter ? setter.call(obj, value) : member.set(obj, value);
return value;
};
var __privateWrapper = (obj, member, setter, getter) => ({
set _(value) {
__privateSet(obj, member, value, setter);
},
get _() {
return __privateGet(obj, member, getter);
}
});
// src/queryClient.ts
var queryClient_exports = {};
__export(queryClient_exports, {
QueryClient: () => QueryClient
});
module.exports = __toCommonJS(queryClient_exports);
var import_utils = require("./utils.cjs");
var import_queryCache = require("./queryCache.cjs");
var import_mutationCache = require("./mutationCache.cjs");
var import_focusManager = require("./focusManager.cjs");
var import_onlineManager = require("./onlineManager.cjs");
var import_notifyManager = require("./notifyManager.cjs");
var import_infiniteQueryBehavior = require("./infiniteQueryBehavior.cjs");
var _queryCache, _mutationCache, _defaultOptions, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline;
var QueryClient = class {
constructor(config = {}) {
__privateAdd(this, _queryCache, void 0);
__privateAdd(this, _mutationCache, void 0);
__privateAdd(this, _defaultOptions, void 0);
__privateAdd(this, _queryDefaults, void 0);
__privateAdd(this, _mutationDefaults, void 0);
__privateAdd(this, _mountCount, void 0);
__privateAdd(this, _unsubscribeFocus, void 0);
__privateAdd(this, _unsubscribeOnline, void 0);
__privateSet(this, _queryCache, config.queryCache || new import_queryCache.QueryCache());
__privateSet(this, _mutationCache, config.mutationCache || new import_mutationCache.MutationCache());
__privateSet(this, _defaultOptions, config.defaultOptions || {});
__privateSet(this, _queryDefaults, /* @__PURE__ */ new Map());
__privateSet(this, _mutationDefaults, /* @__PURE__ */ new Map());
__privateSet(this, _mountCount, 0);
}
mount() {
__privateWrapper(this, _mountCount)._++;
if (__privateGet(this, _mountCount) !== 1)
return;
__privateSet(this, _unsubscribeFocus, import_focusManager.focusManager.subscribe(() => {
if (import_focusManager.focusManager.isFocused()) {
this.resumePausedMutations();
__privateGet(this, _queryCache).onFocus();
}
}));
__privateSet(this, _unsubscribeOnline, import_onlineManager.onlineManager.subscribe(() => {
if (import_onlineManager.onlineManager.isOnline()) {
this.resumePausedMutations();
__privateGet(this, _queryCache).onOnline();
}
}));
}
unmount() {
var _a, _b;
__privateWrapper(this, _mountCount)._--;
if (__privateGet(this, _mountCount) !== 0)
return;
(_a = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a.call(this);
__privateSet(this, _unsubscribeFocus, void 0);
(_b = __privateGet(this, _unsubscribeOnline)) == null ? void 0 : _b.call(this);
__privateSet(this, _unsubscribeOnline, void 0);
}
isFetching(filters) {
return __privateGet(this, _queryCache).findAll({ ...filters, fetchStatus: "fetching" }).length;
}
isMutating(filters) {
return __privateGet(this, _mutationCache).findAll({ ...filters, status: "pending" }).length;
}
getQueryData(queryKey) {
var _a;
return (_a = __privateGet(this, _queryCache).find({ queryKey })) == null ? void 0 : _a.state.data;
}
ensureQueryData(options) {
const cachedData = this.getQueryData(options.queryKey);
return cachedData !== void 0 ? Promise.resolve(cachedData) : this.fetchQuery(options);
}
getQueriesData(filters) {
return this.getQueryCache().findAll(filters).map(({ queryKey, state }) => {
const data = state.data;
return [queryKey, data];
});
}
setQueryData(queryKey, updater, options) {
const query = __privateGet(this, _queryCache).find({ queryKey });
const prevData = query == null ? void 0 : query.state.data;
const data = (0, import_utils.functionalUpdate)(updater, prevData);
if (typeof data === "undefined") {
return void 0;
}
const defaultedOptions = this.defaultQueryOptions({ queryKey });
return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, { ...options, manual: true });
}
setQueriesData(filters, updater, options) {
return import_notifyManager.notifyManager.batch(
() => this.getQueryCache().findAll(filters).map(({ queryKey }) => [
queryKey,
this.setQueryData(queryKey, updater, options)
])
);
}
getQueryState(queryKey) {
var _a;
return (_a = __privateGet(this, _queryCache).find({ queryKey })) == null ? void 0 : _a.state;
}
removeQueries(filters) {
const queryCache = __privateGet(this, _queryCache);
import_notifyManager.notifyManager.batch(() => {
queryCache.findAll(filters).forEach((query) => {
queryCache.remove(query);
});
});
}
resetQueries(filters, options) {
const queryCache = __privateGet(this, _queryCache);
const refetchFilters = {
type: "active",
...filters
};
return import_notifyManager.notifyManager.batch(() => {
queryCache.findAll(filters).forEach((query) => {
query.reset();
});
return this.refetchQueries(refetchFilters, options);
});
}
cancelQueries(filters = {}, cancelOptions = {}) {
const defaultedCancelOptions = { revert: true, ...cancelOptions };
const promises = import_notifyManager.notifyManager.batch(
() => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
);
return Promise.all(promises).then(import_utils.noop).catch(import_utils.noop);
}
invalidateQueries(filters = {}, options = {}) {
return import_notifyManager.notifyManager.batch(() => {
__privateGet(this, _queryCache).findAll(filters).forEach((query) => {
query.invalidate();
});
if (filters.refetchType === "none") {
return Promise.resolve();
}
const refetchFilters = {
...filters,
type: filters.refetchType ?? filters.type ?? "active"
};
return this.refetchQueries(refetchFilters, options);
});
}
refetchQueries(filters = {}, options) {
const fetchOptions = {
...options,
cancelRefetch: (options == null ? void 0 : options.cancelRefetch) ?? true
};
const promises = import_notifyManager.notifyManager.batch(
() => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled()).map((query) => {
let promise = query.fetch(void 0, fetchOptions);
if (!fetchOptions.throwOnError) {
promise = promise.catch(import_utils.noop);
}
return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
})
);
return Promise.all(promises).then(import_utils.noop);
}
fetchQuery(options) {
const defaultedOptions = this.defaultQueryOptions(options);
if (typeof defaultedOptions.retry === "undefined") {
defaultedOptions.retry = false;
}
const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
}
prefetchQuery(options) {
return this.fetchQuery(options).then(import_utils.noop).catch(import_utils.noop);
}
fetchInfiniteQuery(options) {
options.behavior = (0, import_infiniteQueryBehavior.infiniteQueryBehavior)(options.pages);
return this.fetchQuery(options);
}
prefetchInfiniteQuery(options) {
return this.fetchInfiniteQuery(options).then(import_utils.noop).catch(import_utils.noop);
}
resumePausedMutations() {
return __privateGet(this, _mutationCache).resumePausedMutations();
}
getQueryCache() {
return __privateGet(this, _queryCache);
}
getMutationCache() {
return __privateGet(this, _mutationCache);
}
getDefaultOptions() {
return __privateGet(this, _defaultOptions);
}
setDefaultOptions(options) {
__privateSet(this, _defaultOptions, options);
}
setQueryDefaults(queryKey, options) {
__privateGet(this, _queryDefaults).set((0, import_utils.hashKey)(queryKey), {
queryKey,
defaultOptions: options
});
}
getQueryDefaults(queryKey) {
const defaults = [...__privateGet(this, _queryDefaults).values()];
let result = {};
defaults.forEach((queryDefault) => {
if ((0, import_utils.partialMatchKey)(queryKey, queryDefault.queryKey)) {
result = { ...result, ...queryDefault.defaultOptions };
}
});
return result;
}
setMutationDefaults(mutationKey, options) {
__privateGet(this, _mutationDefaults).set((0, import_utils.hashKey)(mutationKey), {
mutationKey,
defaultOptions: options
});
}
getMutationDefaults(mutationKey) {
const defaults = [...__privateGet(this, _mutationDefaults).values()];
let result = {};
defaults.forEach((queryDefault) => {
if ((0, import_utils.partialMatchKey)(mutationKey, queryDefault.mutationKey)) {
result = { ...result, ...queryDefault.defaultOptions };
}
});
return result;
}
defaultQueryOptions(options) {
if (options == null ? void 0 : options._defaulted) {
return options;
}
const defaultedOptions = {
...__privateGet(this, _defaultOptions).queries,
...(options == null ? void 0 : options.queryKey) && this.getQueryDefaults(options.queryKey),
...options,
_defaulted: true
};
if (!defaultedOptions.queryHash) {
defaultedOptions.queryHash = (0, import_utils.hashQueryKeyByOptions)(
defaultedOptions.queryKey,
defaultedOptions
);
}
if (typeof defaultedOptions.refetchOnReconnect === "undefined") {
defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
}
if (typeof defaultedOptions.throwOnError === "undefined") {
defaultedOptions.throwOnError = !!defaultedOptions.suspense;
}
if (typeof defaultedOptions.networkMode === "undefined" && defaultedOptions.persister) {
defaultedOptions.networkMode = "offlineFirst";
}
return defaultedOptions;
}
defaultMutationOptions(options) {
if (options == null ? void 0 : options._defaulted) {
return options;
}
return {
...__privateGet(this, _defaultOptions).mutations,
...(options == null ? void 0 : options.mutationKey) && this.getMutationDefaults(options.mutationKey),
...options,
_defaulted: true
};
}
clear() {
__privateGet(this, _queryCache).clear();
__privateGet(this, _mutationCache).clear();
}
};
_queryCache = new WeakMap();
_mutationCache = new WeakMap();
_defaultOptions = new WeakMap();
_queryDefaults = new WeakMap();
_mutationDefaults = new WeakMap();
_mountCount = new WeakMap();
_unsubscribeFocus = new WeakMap();
_unsubscribeOnline = new WeakMap();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
QueryClient
});
//# sourceMappingURL=queryClient.cjs.map