@tanstack/query-core
Version:
The framework agnostic core that powers TanStack Query
260 lines (259 loc) • 10.9 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __typeError = (msg) => {
throw TypeError(msg);
};
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) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __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), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
// src/queriesObserver.ts
var queriesObserver_exports = {};
__export(queriesObserver_exports, {
QueriesObserver: () => QueriesObserver
});
module.exports = __toCommonJS(queriesObserver_exports);
var import_notifyManager = require("./notifyManager.cjs");
var import_queryObserver = require("./queryObserver.cjs");
var import_subscribable = require("./subscribable.cjs");
var import_utils = require("./utils.cjs");
function difference(array1, array2) {
const excludeSet = new Set(array2);
return array1.filter((x) => !excludeSet.has(x));
}
function replaceAt(array, index, value) {
const copy = array.slice(0);
copy[index] = value;
return copy;
}
var _client, _result, _queries, _options, _observers, _combinedResult, _lastCombine, _lastResult, _lastQueryHashes, _observerMatches, _QueriesObserver_instances, trackResult_fn, combineResult_fn, findMatchingObservers_fn, onUpdate_fn, notify_fn;
var QueriesObserver = class extends import_subscribable.Subscribable {
constructor(client, queries, options) {
super();
__privateAdd(this, _QueriesObserver_instances);
__privateAdd(this, _client);
__privateAdd(this, _result);
__privateAdd(this, _queries);
__privateAdd(this, _options);
__privateAdd(this, _observers);
__privateAdd(this, _combinedResult);
__privateAdd(this, _lastCombine);
__privateAdd(this, _lastResult);
__privateAdd(this, _lastQueryHashes);
__privateAdd(this, _observerMatches, []);
__privateSet(this, _client, client);
__privateSet(this, _options, options);
__privateSet(this, _queries, []);
__privateSet(this, _observers, []);
__privateSet(this, _result, []);
this.setQueries(queries);
}
onSubscribe() {
if (this.listeners.size === 1) {
__privateGet(this, _observers).forEach((observer) => {
observer.subscribe((result) => {
__privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
});
});
}
}
onUnsubscribe() {
if (!this.listeners.size) {
this.destroy();
}
}
destroy() {
this.listeners = /* @__PURE__ */ new Set();
__privateGet(this, _observers).forEach((observer) => {
observer.destroy();
});
}
setQueries(queries, options) {
__privateSet(this, _queries, queries);
__privateSet(this, _options, options);
if (process.env.NODE_ENV !== "production") {
const queryHashes = queries.map(
(query) => __privateGet(this, _client).defaultQueryOptions(query).queryHash
);
if (new Set(queryHashes).size !== queryHashes.length) {
console.warn(
"[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior."
);
}
}
import_notifyManager.notifyManager.batch(() => {
const prevObservers = __privateGet(this, _observers);
const newObserverMatches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, __privateGet(this, _queries));
newObserverMatches.forEach(
(match) => match.observer.setOptions(match.defaultedQueryOptions)
);
const newObservers = newObserverMatches.map((match) => match.observer);
const newResult = newObservers.map(
(observer) => observer.getCurrentResult()
);
const hasLengthChange = prevObservers.length !== newObservers.length;
const hasIndexChange = newObservers.some(
(observer, index) => observer !== prevObservers[index]
);
const hasStructuralChange = hasLengthChange || hasIndexChange;
const hasResultChange = hasStructuralChange ? true : newResult.some((result, index) => {
const prev = __privateGet(this, _result)[index];
return !prev || !(0, import_utils.shallowEqualObjects)(result, prev);
});
if (!hasStructuralChange && !hasResultChange) return;
if (hasStructuralChange) {
__privateSet(this, _observerMatches, newObserverMatches);
__privateSet(this, _observers, newObservers);
}
__privateSet(this, _result, newResult);
if (!this.hasListeners()) return;
if (hasStructuralChange) {
difference(prevObservers, newObservers).forEach((observer) => {
observer.destroy();
});
difference(newObservers, prevObservers).forEach((observer) => {
observer.subscribe((result) => {
__privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
});
});
}
__privateMethod(this, _QueriesObserver_instances, notify_fn).call(this);
});
}
getCurrentResult() {
return __privateGet(this, _result);
}
getQueries() {
return __privateGet(this, _observers).map((observer) => observer.getCurrentQuery());
}
getObservers() {
return __privateGet(this, _observers);
}
getOptimisticResult(queries, combine) {
const matches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, queries);
const result = matches.map(
(match) => match.observer.getOptimisticResult(match.defaultedQueryOptions)
);
const queryHashes = matches.map(
(match) => match.defaultedQueryOptions.queryHash
);
return [
result,
(r) => {
return __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, r ?? result, combine, queryHashes);
},
() => {
return __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, result, matches);
}
];
}
};
_client = new WeakMap();
_result = new WeakMap();
_queries = new WeakMap();
_options = new WeakMap();
_observers = new WeakMap();
_combinedResult = new WeakMap();
_lastCombine = new WeakMap();
_lastResult = new WeakMap();
_lastQueryHashes = new WeakMap();
_observerMatches = new WeakMap();
_QueriesObserver_instances = new WeakSet();
trackResult_fn = function(result, matches) {
return matches.map((match, index) => {
const observerResult = result[index];
return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {
matches.forEach((m) => {
m.observer.trackProp(accessedProp);
});
}) : observerResult;
});
};
combineResult_fn = function(input, combine, queryHashes) {
if (combine) {
const lastHashes = __privateGet(this, _lastQueryHashes);
const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i]));
if (!__privateGet(this, _combinedResult) || __privateGet(this, _result) !== __privateGet(this, _lastResult) || queryHashesChanged || combine !== __privateGet(this, _lastCombine)) {
__privateSet(this, _lastCombine, combine);
__privateSet(this, _lastResult, __privateGet(this, _result));
if (queryHashes !== void 0) {
__privateSet(this, _lastQueryHashes, queryHashes);
}
__privateSet(this, _combinedResult, (0, import_utils.replaceEqualDeep)(
__privateGet(this, _combinedResult),
combine(input)
));
}
return __privateGet(this, _combinedResult);
}
return input;
};
findMatchingObservers_fn = function(queries) {
const prevObserversMap = /* @__PURE__ */ new Map();
__privateGet(this, _observers).forEach((observer) => {
const key = observer.options.queryHash;
if (!key) return;
const previousObservers = prevObserversMap.get(key);
if (previousObservers) {
previousObservers.push(observer);
} else {
prevObserversMap.set(key, [observer]);
}
});
const observers = [];
queries.forEach((options) => {
var _a;
const defaultedOptions = __privateGet(this, _client).defaultQueryOptions(options);
const match = (_a = prevObserversMap.get(defaultedOptions.queryHash)) == null ? void 0 : _a.shift();
const observer = match ?? new import_queryObserver.QueryObserver(__privateGet(this, _client), defaultedOptions);
observers.push({
defaultedQueryOptions: defaultedOptions,
observer
});
});
return observers;
};
onUpdate_fn = function(observer, result) {
const index = __privateGet(this, _observers).indexOf(observer);
if (index !== -1) {
__privateSet(this, _result, replaceAt(__privateGet(this, _result), index, result));
__privateMethod(this, _QueriesObserver_instances, notify_fn).call(this);
}
};
notify_fn = function() {
var _a;
if (this.hasListeners()) {
const previousResult = __privateGet(this, _combinedResult);
const newTracked = __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, __privateGet(this, _result), __privateGet(this, _observerMatches));
const newResult = __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, newTracked, (_a = __privateGet(this, _options)) == null ? void 0 : _a.combine);
if (previousResult !== newResult) {
import_notifyManager.notifyManager.batch(() => {
this.listeners.forEach((listener) => {
listener(__privateGet(this, _result));
});
});
}
}
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
QueriesObserver
});
//# sourceMappingURL=queriesObserver.cjs.map