@ventlio/tanstack-query 0.5.3 → 0.5.5

package/dist/queries/useDeleteRequest.js

@@ -9,77 +9,92 @@ import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
 
-const useDeleteRequest = (deleteOptions) => {
-    const { baseUrl, headers } = deleteOptions ?? {};
-    const [requestPath, setRequestPath] = useState('');
-    const [options, setOptions] = useState();
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const sendRequest = async (res, rej, queryKey) => {
-        const [url] = queryKey;
-        const requestUrl = (url ?? requestPath);
-        const requestOptions = {
-            path: requestUrl,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            method: HttpMethod.DELETE,
-            timeout: TIMEOUT,
-        };
-        let shouldContinue = true;
-        if (queryConfigOptions?.queryMiddleware) {
-            shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-        }
-        if (shouldContinue) {
-            const postResponse = await makeRequest(requestOptions);
-            if (postResponse.status) {
-                res(postResponse);
-            }
-            else {
-                rej(postResponse);
-            }
-        }
-        else {
-            rej(null);
-        }
-    };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: false,
-        ...options,
-    });
-    const updatedPathAsync = async (link) => {
-        return setRequestPath(link);
-    };
-    const setOptionsAsync = async (fetchOptions) => {
-        return setOptions(fetchOptions);
-    };
-    const destroy = async (link, internalDeleteOptions) => {
-        if (!isFutureQueriesPaused) {
-            // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions
-                ? { ...internalDeleteOptions, queryKey: [link, {}], enabled: true }
-                : { queryKey: [link, {}], enabled: true };
-            await setOptionsAsync(internalDeleteOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, internalDeleteOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    return { destroy, ...query, isLoading: query.isLoading || isFutureQueriesPaused };
+const useDeleteRequest = (deleteOptions) => {
+    const { baseUrl, headers } = deleteOptions ?? {};
+    const [requestPath, setRequestPath] = useState('');
+    const [options, setOptions] = useState();
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const sendRequest = async (res, rej, queryKey) => {
+        const [url] = queryKey;
+        const requestUrl = (url ?? requestPath);
+        const requestOptions = {
+            path: requestUrl,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            method: HttpMethod.DELETE,
+            timeout: TIMEOUT,
+        };
+        let shouldContinue = true;
+        if (queryConfigOptions?.queryMiddleware) {
+            shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+        }
+        if (shouldContinue) {
+            let deleteResponse;
+            if (queryConfigOptions?.middleware) {
+                // perform global middleware
+                const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                    path: requestUrl,
+                    baseUrl: baseUrl ?? API_URL,
+                });
+                if (!middlewareResponse) {
+                    rej();
+                    return;
+                }
+                deleteResponse = middlewareResponse;
+            }
+            else {
+                deleteResponse = await makeRequest(requestOptions);
+            }
+            if (deleteResponse.status) {
+                res(deleteResponse);
+            }
+            else {
+                rej(deleteResponse);
+            }
+        }
+        else {
+            rej(null);
+        }
+    };
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: false,
+        ...options,
+    });
+    const updatedPathAsync = async (link) => {
+        return setRequestPath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const destroy = async (link, internalDeleteOptions) => {
+        if (!isFutureQueriesPaused) {
+            // set enabled to be true for every delete
+            internalDeleteOptions = internalDeleteOptions
+                ? { ...internalDeleteOptions, queryKey: [link, {}], enabled: true }
+                : { queryKey: [link, {}], enabled: true };
+            await setOptionsAsync(internalDeleteOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, internalDeleteOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    return { destroy, ...query, isLoading: query.isLoading || isFutureQueriesPaused };
 };
 
 export { useDeleteRequest };

package/dist/queries/useDeleteRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDeleteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useDeleteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/useGetInfiniteRequest.d.ts

@@ -1,110 +1,108 @@
-import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
-import type { IRequestError, IRequestSuccess } from '../request';
-import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
-interface Pagination {
-    previous_page: number;
-    current_page: number;
-    next_page: number;
-    size: number;
-    page_count: number;
-    total: number;
-}
-export declare const useGetInfiniteRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, keyTracker, baseUrl, headers, }: {
-    path: string;
-    load?: boolean | undefined;
-    queryOptions?: Partial<import("@tanstack/react-query/build/legacy/types").UseInfiniteQueryOptions<IRequestSuccess<(TResponse & {
-        pagination: Pagination;
-    }) | undefined>, IRequestError, IRequestSuccess<(TResponse & {
-        pagination: Pagination;
-    }) | undefined>, any[], QueryKey, unknown>> | undefined;
-    keyTracker?: string | undefined;
-} & DefaultRequestOptions) => {
-    isLoading: boolean;
-    data: InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>;
-    error: any;
-    isError: true;
-    isPending: false;
-    isLoadingError: false;
-    isRefetchError: true;
-    isFetchNextPageError: false;
-    isFetchPreviousPageError: false;
-    isSuccess: false;
-    status: "error";
-    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ah | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").aA<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ai | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").aA<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-    isFetchingNextPage: boolean;
-    isFetchingPreviousPage: boolean;
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ac | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").as<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ak;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown> | undefined>;
-} | {
-    isLoading: boolean;
-    data: InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>;
-    error: null;
-    isError: false;
-    isPending: false;
-    isLoadingError: false;
-    isRefetchError: false;
-    isFetchNextPageError: false;
-    isFetchPreviousPageError: false;
-    isSuccess: true;
-    status: "success";
-    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ah | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").aA<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ai | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").aA<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-    isFetchingNextPage: boolean;
-    isFetchingPreviousPage: boolean;
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: (options?: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ac | undefined) => Promise<import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").as<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/hydration-BZ2M_xzi").ak;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
-        pagination: Pagination;
-    }>, unknown> | undefined>;
-};
-export {};
+import type { InfiniteData, UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
+interface Pagination {
+    previous_page: number;
+    current_page: number;
+    next_page: number;
+    size: number;
+    page_count: number;
+    total: number;
+}
+export declare const useGetInfiniteRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, keyTracker, baseUrl, headers, }: {
+    path: string;
+    load?: boolean;
+    queryOptions?: TanstackInfiniteQueryOption<TResponse & {
+        pagination: Pagination;
+    }>;
+    keyTracker?: string;
+} & DefaultRequestOptions) => {
+    isLoading: boolean;
+    data: InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>;
+    error: any;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>) => Promise<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>> | undefined>;
+} | {
+    isLoading: boolean;
+    data: InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    status: "success";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: any;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, unknown>, any>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>) => Promise<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>> | undefined>;
+};
+export {};

package/dist/queries/useGetInfiniteRequest.js

@@ -9,108 +9,123 @@ import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
 
-const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const [requestPath, setRequestPath] = useState(path);
-    const [options, setOptions] = useState(queryOptions);
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    let queryClient = useQueryClient();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, queryKey, pageParam) => {
-        if (load) {
-            // get request headers
-            const requestOptions = {
-                path: pageParam ?? requestPath,
-                headers: { ...globalHeaders, ...headers },
-                baseURL: baseUrl ?? API_URL,
-                timeout: TIMEOUT,
-            };
-            let shouldContinue = true;
-            if (queryConfigOptions?.queryMiddleware) {
-                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-            }
-            if (shouldContinue) {
-                const getResponse = await makeRequest(requestOptions);
-                if (getResponse.status) {
-                    res(getResponse);
-                }
-                else {
-                    rej(getResponse);
-                }
-            }
-            else {
-                rej(null);
-            }
-        }
-        else {
-            res(null);
-        }
-    };
-    /**
-     *
-     * This pagination implementation is currently tied to our use case
-     */
-    const constructPaginationLink = (direction, lastPage) => {
-        const [pathname, queryString] = requestPath.split('?');
-        const queryParams = new URLSearchParams(queryString);
-        const lastPageItem = lastPage.data.pagination[direction];
-        queryParams.set('page', String(lastPageItem));
-        return pathname + '?' + queryParams.toString();
-    };
-    const query = useInfiniteQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
-        enabled: load && !isFutureQueriesPaused,
-        getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
-        getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
-        ...options,
-    });
-    const setOptionsAsync = async (fetchOptions) => {
-        startTransition(() => {
-            setOptions(fetchOptions);
-        });
-    };
-    const get = async (link, fetchOptions) => {
-        if (!isFutureQueriesPaused) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, fetchOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            get(requestPayload.link, requestPayload.fetchOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    const updatedPathAsync = async (link) => {
-        startTransition(() => {
-            setRequestPath(link);
-        });
-    };
-    useEffect(() => {
-        if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
-        }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
-    return {
-        get,
-        ...query,
-        isLoading: query.isLoading || isFutureQueriesPaused,
-    };
+const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const [requestPath, setRequestPath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    let queryClient = useQueryClient();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    queryClient = useMemo(() => queryClient, []);
+    const sendRequest = async (res, rej, queryKey, pageParam) => {
+        if (load) {
+            // get request headers
+            const requestOptions = {
+                path: pageParam ?? requestPath,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            };
+            let shouldContinue = true;
+            if (queryConfigOptions?.queryMiddleware) {
+                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+            }
+            if (shouldContinue) {
+                let getResponse;
+                if (queryConfigOptions?.middleware) {
+                    // perform global middleware
+                    const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                        path,
+                        baseUrl: baseUrl ?? API_URL,
+                    });
+                    if (!middlewareResponse) {
+                        rej();
+                        return;
+                    }
+                    getResponse = middlewareResponse;
+                }
+                else {
+                    getResponse = await makeRequest(requestOptions);
+                }
+                if (getResponse.status) {
+                    res(getResponse);
+                }
+                else {
+                    rej(getResponse);
+                }
+            }
+            else {
+                rej(null);
+            }
+        }
+        else {
+            res(null);
+        }
+    };
+    /**
+     *
+     * This pagination implementation is currently tied to our use case
+     */
+    const constructPaginationLink = (direction, lastPage) => {
+        const [pathname, queryString] = requestPath.split('?');
+        const queryParams = new URLSearchParams(queryString);
+        const lastPageItem = lastPage.data.pagination[direction];
+        queryParams.set('page', String(lastPageItem));
+        return pathname + '?' + queryParams.toString();
+    };
+    const query = useInfiniteQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
+        enabled: load && !isFutureQueriesPaused,
+        getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
+        getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
+        ...options,
+    });
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        if (!isFutureQueriesPaused) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, fetchOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            setRequestPath(link);
+        });
+    };
+    useEffect(() => {
+        if (keyTracker) {
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+        }
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+    return {
+        get,
+        ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
+    };
 };
 
 export { useGetInfiniteRequest };

package/dist/queries/useGetInfiniteRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGetInfiniteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useGetInfiniteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}