Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/react-query/es/core/infiniteQueryBehavior.js
f646e1f695a7paginated-inlines

infiniteQueryBehavior.js
View Options

			import { isCancelable } from './retryer';
			import { getAbortController } from './utils';
			export function infiniteQueryBehavior() {
			return {
			onFetch: function onFetch(context) {
			context.fetchFn = function () {
			var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;

			var refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
			var fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
			var pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
			var isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
			var isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
			var oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) \|\| [];
			var oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) \|\| [];
			var abortController = getAbortController();
			var abortSignal = abortController == null ? void 0 : abortController.signal;
			var newPageParams = oldPageParams;
			var cancelled = false; // Get query function

			var queryFn = context.options.queryFn \|\| function () {
			return Promise.reject('Missing queryFn');
			};

			var buildNewPages = function buildNewPages(pages, param, page, previous) {
			newPageParams = previous ? [param].concat(newPageParams) : [].concat(newPageParams, [param]);
			return previous ? [page].concat(pages) : [].concat(pages, [page]);
			}; // Create function to fetch a page


			var fetchPage = function fetchPage(pages, manual, param, previous) {
			if (cancelled) {
			return Promise.reject('Cancelled');
			}

			if (typeof param === 'undefined' && !manual && pages.length) {
			return Promise.resolve(pages);
			}

			var queryFnContext = {
			queryKey: context.queryKey,
			signal: abortSignal,
			pageParam: param,
			meta: context.meta
			};
			var queryFnResult = queryFn(queryFnContext);
			var promise = Promise.resolve(queryFnResult).then(function (page) {
			return buildNewPages(pages, param, page, previous);
			});

			if (isCancelable(queryFnResult)) {
			var promiseAsAny = promise;
			promiseAsAny.cancel = queryFnResult.cancel;
			}

			return promise;
			};

			var promise; // Fetch first page?

			if (!oldPages.length) {
			promise = fetchPage([]);
			} // Fetch next page?
			else if (isFetchingNextPage) {
			var manual = typeof pageParam !== 'undefined';
			var param = manual ? pageParam : getNextPageParam(context.options, oldPages);
			promise = fetchPage(oldPages, manual, param);
			} // Fetch previous page?
			else if (isFetchingPreviousPage) {
			var _manual = typeof pageParam !== 'undefined';

			var _param = _manual ? pageParam : getPreviousPageParam(context.options, oldPages);

			promise = fetchPage(oldPages, _manual, _param, true);
			} // Refetch pages
			else {
			(function () {
			newPageParams = [];
			var manual = typeof context.options.getNextPageParam === 'undefined';
			var shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page

			promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages

			var _loop = function _loop(i) {
			promise = promise.then(function (pages) {
			var shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;

			if (shouldFetchNextPage) {
			var _param2 = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);

			return fetchPage(pages, manual, _param2);
			}

			return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
			});
			};

			for (var i = 1; i < oldPages.length; i++) {
			_loop(i);
			}
			})();
			}

			var finalPromise = promise.then(function (pages) {
			return {
			pages: pages,
			pageParams: newPageParams
			};
			});
			var finalPromiseAsAny = finalPromise;

			finalPromiseAsAny.cancel = function () {
			cancelled = true;
			abortController == null ? void 0 : abortController.abort();

			if (isCancelable(promise)) {
			promise.cancel();
			}
			};

			return finalPromise;
			};
			}
			};
			}
			export function getNextPageParam(options, pages) {
			return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
			}
			export function getPreviousPageParam(options, pages) {
			return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);
			}
			/**
			* Checks if there is a next page.
			* Returns `undefined` if it cannot be determined.
			*/

			export function hasNextPage(options, pages) {
			if (options.getNextPageParam && Array.isArray(pages)) {
			var nextPageParam = getNextPageParam(options, pages);
			return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;
			}
			}
			/**
			* Checks if there is a previous page.
			* Returns `undefined` if it cannot be determined.
			*/

			export function hasPreviousPage(options, pages) {
			if (options.getPreviousPageParam && Array.isArray(pages)) {
			var previousPageParam = getPreviousPageParam(options, pages);
			return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;
			}
			}