Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/react-query/es/core/queriesObserver.js
49c99f97fe9aissn4frontend

queriesObserver.js
View Options

			import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
			import { difference, replaceAt } from './utils';
			import { notifyManager } from './notifyManager';
			import { QueryObserver } from './queryObserver';
			import { Subscribable } from './subscribable';
			export var QueriesObserver = /#__PURE__/function (_Subscribable) {
			_inheritsLoose(QueriesObserver, _Subscribable);

			function QueriesObserver(client, queries) {
			var _this;

			_this = _Subscribable.call(this) \|\| this;
			_this.client = client;
			_this.queries = [];
			_this.result = [];
			_this.observers = [];
			_this.observersMap = {};

			if (queries) {
			_this.setQueries(queries);
			}

			return _this;
			}

			var _proto = QueriesObserver.prototype;

			_proto.onSubscribe = function onSubscribe() {
			var _this2 = this;

			if (this.listeners.length === 1) {
			this.observers.forEach(function (observer) {
			observer.subscribe(function (result) {
			_this2.onUpdate(observer, result);
			});
			});
			}
			};

			_proto.onUnsubscribe = function onUnsubscribe() {
			if (!this.listeners.length) {
			this.destroy();
			}
			};

			_proto.destroy = function destroy() {
			this.listeners = [];
			this.observers.forEach(function (observer) {
			observer.destroy();
			});
			};

			_proto.setQueries = function setQueries(queries, notifyOptions) {
			this.queries = queries;
			this.updateObservers(notifyOptions);
			};

			_proto.getCurrentResult = function getCurrentResult() {
			return this.result;
			};

			_proto.getOptimisticResult = function getOptimisticResult(queries) {
			return this.findMatchingObservers(queries).map(function (match) {
			return match.observer.getOptimisticResult(match.defaultedQueryOptions);
			});
			};

			_proto.findMatchingObservers = function findMatchingObservers(queries) {
			var _this3 = this;

			var prevObservers = this.observers;
			var defaultedQueryOptions = queries.map(function (options) {
			return _this3.client.defaultQueryObserverOptions(options);
			});
			var matchingObservers = defaultedQueryOptions.flatMap(function (defaultedOptions) {
			var match = prevObservers.find(function (observer) {
			return observer.options.queryHash === defaultedOptions.queryHash;
			});

			if (match != null) {
			return [{
			defaultedQueryOptions: defaultedOptions,
			observer: match
			}];
			}

			return [];
			});
			var matchedQueryHashes = matchingObservers.map(function (match) {
			return match.defaultedQueryOptions.queryHash;
			});
			var unmatchedQueries = defaultedQueryOptions.filter(function (defaultedOptions) {
			return !matchedQueryHashes.includes(defaultedOptions.queryHash);
			});
			var unmatchedObservers = prevObservers.filter(function (prevObserver) {
			return !matchingObservers.some(function (match) {
			return match.observer === prevObserver;
			});
			});
			var newOrReusedObservers = unmatchedQueries.map(function (options, index) {
			if (options.keepPreviousData) {
			// return previous data from one of the observers that no longer match
			var previouslyUsedObserver = unmatchedObservers[index];

			if (previouslyUsedObserver !== undefined) {
			return {
			defaultedQueryOptions: options,
			observer: previouslyUsedObserver
			};
			}
			}

			return {
			defaultedQueryOptions: options,
			observer: _this3.getObserver(options)
			};
			});

			var sortMatchesByOrderOfQueries = function sortMatchesByOrderOfQueries(a, b) {
			return defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);
			};

			return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
			};

			_proto.getObserver = function getObserver(options) {
			var defaultedOptions = this.client.defaultQueryObserverOptions(options);
			var currentObserver = this.observersMap[defaultedOptions.queryHash];
			return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
			};

			_proto.updateObservers = function updateObservers(notifyOptions) {
			var _this4 = this;

			notifyManager.batch(function () {
			var prevObservers = _this4.observers;

			var newObserverMatches = _this4.findMatchingObservers(_this4.queries); // set options for the new observers to notify of changes


			newObserverMatches.forEach(function (match) {
			return match.observer.setOptions(match.defaultedQueryOptions, notifyOptions);
			});
			var newObservers = newObserverMatches.map(function (match) {
			return match.observer;
			});
			var newObserversMap = Object.fromEntries(newObservers.map(function (observer) {
			return [observer.options.queryHash, observer];
			}));
			var newResult = newObservers.map(function (observer) {
			return observer.getCurrentResult();
			});
			var hasIndexChange = newObservers.some(function (observer, index) {
			return observer !== prevObservers[index];
			});

			if (prevObservers.length === newObservers.length && !hasIndexChange) {
			return;
			}

			_this4.observers = newObservers;
			_this4.observersMap = newObserversMap;
			_this4.result = newResult;

			if (!_this4.hasListeners()) {
			return;
			}

			difference(prevObservers, newObservers).forEach(function (observer) {
			observer.destroy();
			});
			difference(newObservers, prevObservers).forEach(function (observer) {
			observer.subscribe(function (result) {
			_this4.onUpdate(observer, result);
			});
			});

			_this4.notify();
			});
			};

			_proto.onUpdate = function onUpdate(observer, result) {
			var index = this.observers.indexOf(observer);

			if (index !== -1) {
			this.result = replaceAt(this.result, index, result);
			this.notify();
			}
			};

			_proto.notify = function notify() {
			var _this5 = this;

			notifyManager.batch(function () {
			_this5.listeners.forEach(function (listener) {
			listener(_this5.result);
			});
			});
			};

			return QueriesObserver;
			}(Subscribable);