@ventlio/tanstack-query 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from './config';
 export * from './helpers';
+export * from './hooks';
 export * from './model';
 export * from './queries';
 export * from './request';
+export * from './stores';
 export * from './types';

package/dist/index.js

@@ -5,6 +5,7 @@ export { useQueryHeaders } from './config/useQueryHeaders.js';
 export { useReactNativeEnv } from './config/useReactNativeEnv.js';
 export { scrollToTop } from './helpers/scrollToTop.js';
 export { getDateInFuture } from './helpers/timeFuncs.js';
+export { useUploadProgress } from './hooks/useUploadProgress.js';
 export { useKeyTrackerModel } from './model/useKeyTrackerModel.js';
 export { useQueryModel } from './model/useQueryModel.js';
 export { useRefetchQuery } from './model/useRefetchQuery.js';
@@ -18,4 +19,5 @@ export { buildFormData } from './request/buildFormData.js';
 export { makeRequest } from './request/make-request.js';
 export { ContentType, HttpMethod } from './request/request.enum.js';
 export { errorTransformer, successTransformer } from './request/transformer.js';
+export { usePauseFutureRequests } from './stores/usePauseFutureRequests.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import 'url-search-params-polyfill';
 import { useQueryClient, useQuery, useInfiniteQuery, useMutation } from '@tanstack/react-query';
+import { useState, useEffect, useMemo, startTransition } from 'react';
 import result from 'lodash.result';
 import lodashSet from 'lodash.set';
-import { useState, useMemo, useEffect, startTransition } from 'react';
 import axios from 'axios';
+import { create } from 'zustand';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
@@ -84,6 +85,16 @@ function getDateInFuture(days) {
     return date.getTime();
 }
 
+const useUploadProgress = () => {
+    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
+    const onUploadProgress = (progressEvent) => {
+        const { loaded, total } = progressEvent;
+        const percentage = Math.round((loaded / total) * 100);
+        setUploadProgressPercent(percentage);
+    };
+    return { onUploadProgress, uploadProgressPercent };
+};
+
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
@@ -391,11 +402,28 @@ function getAppFiles(body, fileSelectors = []) {
     return files;
 }
 
+const usePauseFutureRequests = create((set) => {
+    const pauseFutureQueries = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    const pauseFutureMutation = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    return {
+        isFutureMutationsPaused: false,
+        isFutureQueriesPaused: false,
+        pauseFutureQueries,
+        pauseFutureMutation,
+    };
+});
+
 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 { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, queryKey) => {
@@ -434,14 +462,27 @@ const useDeleteRequest = (deleteOptions) => {
         return setOptions(fetchOptions);
     };
     const destroy = async (link, internalDeleteOptions) => {
-        // set enabled to be true for every delete
-        internalDeleteOptions = internalDeleteOptions ?? {};
-        internalDeleteOptions.enabled = true;
-        await setOptionsAsync(internalDeleteOptions);
-        await updatedPathAsync(link);
-        return query.data;
-    };
-    return { destroy, ...query };
+        if (!isFutureQueriesPaused) {
+            // set enabled to be true for every delete
+            internalDeleteOptions = internalDeleteOptions ?? {};
+            internalDeleteOptions.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 useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
@@ -450,6 +491,8 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     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, []);
@@ -496,7 +539,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         return pathname + '?' + queryParams.toString();
     };
     const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
-        enabled: load,
+        enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -507,10 +550,23 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        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);
@@ -529,6 +585,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     return {
         get,
         ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
     };
 };
 
@@ -539,6 +596,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     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, []);
@@ -576,7 +635,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         }
     };
     const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), {
-        enabled: load,
+        enabled: load && !isFutureQueriesPaused,
         ...options,
     });
     useEffect(() => {
@@ -636,12 +695,26 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        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]);
     return {
         ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
         setRequestPath,
         nextPage,
         prevPage,
@@ -652,19 +725,11 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
 };
 
-const useUploadProgress = () => {
-    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
-    const onUploadProgress = (progressEvent) => {
-        const { loaded, total } = progressEvent;
-        const percentage = Math.round((loaded / total) * 100);
-        setUploadProgressPercent(percentage);
-    };
-    return { onUploadProgress, uploadProgressPercent };
-};
-
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
@@ -712,9 +777,22 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         return sendRequest(res, rej, dataData);
     }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (data, options) => {
-        return mutation.mutateAsync(data, options);
+        if (!isFutureMutationsPaused) {
+            return mutation.mutateAsync(data, options);
+        }
+        else {
+            setRequestPayload({ data, options });
+            return undefined;
+        }
     };
-    return { patch, uploadProgressPercent, ...mutation };
+    useEffect(() => {
+        if (!isFutureMutationsPaused && requestPayload) {
+            patch(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureMutationsPaused]);
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
@@ -723,6 +801,8 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
     const { getHeaders } = useQueryHeaders();
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const sendRequest = async (res, rej, postData) => {
         // get request headers
         const globalHeaders = getHeaders();
@@ -776,11 +856,24 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
-        const { requestConfig, ...otherOptions } = options ?? {};
-        return mutation.mutateAsync({ data, requestConfig }, otherOptions);
+        if (!isFutureMutationsPaused) {
+            const { requestConfig, ...otherOptions } = options ?? {};
+            return mutation.mutateAsync({ data, requestConfig }, otherOptions);
+        }
+        else {
+            setRequestPayload({ data, options });
+            return undefined;
+        }
     };
-    return { post, uploadProgressPercent, ...mutation };
+    useEffect(() => {
+        if (!isFutureMutationsPaused && requestPayload) {
+            post(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureMutationsPaused]);
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
-export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery };
+export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/dist/queries/useDeleteRequest.d.ts

@@ -2,10 +2,10 @@ import type { UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
 import type { DefaultRequestOptions } from './queries.interface';
 export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultRequestOptions) => {
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -31,10 +31,10 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -60,10 +60,10 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
+    isLoading: boolean;
     data: undefined;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
@@ -89,10 +89,10 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;

package/dist/queries/useDeleteRequest.js

@@ -1,5 +1,5 @@
 import { useQuery } from '@tanstack/react-query';
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
@@ -7,12 +7,15 @@ import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.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 { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, queryKey) => {
@@ -51,14 +54,27 @@ const useDeleteRequest = (deleteOptions) => {
         return setOptions(fetchOptions);
     };
     const destroy = async (link, internalDeleteOptions) => {
-        // set enabled to be true for every delete
-        internalDeleteOptions = internalDeleteOptions ?? {};
-        internalDeleteOptions.enabled = true;
-        await setOptionsAsync(internalDeleteOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        if (!isFutureQueriesPaused) {
+            // set enabled to be true for every delete
+            internalDeleteOptions = internalDeleteOptions ?? {};
+            internalDeleteOptions.enabled = true;
+            await setOptionsAsync(internalDeleteOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, internalDeleteOptions });
+            return undefined;
+        }
     };
-    return { destroy, ...query };
+    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

@@ -17,10 +17,10 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     }> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
+    isLoading: boolean;
     data: undefined;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
@@ -58,10 +58,10 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;
@@ -99,12 +99,12 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -142,12 +142,12 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;
     error: null;
     isError: false;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;

package/dist/queries/useGetInfiniteRequest.js

@@ -7,6 +7,7 @@ import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
@@ -14,6 +15,8 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     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, []);
@@ -60,7 +63,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         return pathname + '?' + queryParams.toString();
     };
     const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
-        enabled: load,
+        enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -71,10 +74,23 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        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);
@@ -93,6 +109,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     return {
         get,
         ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
     };
 };
 

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/useGetRequest.d.ts

@@ -8,6 +8,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     queryOptions?: TanstackQueryOption<TResponse> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -18,7 +19,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -41,6 +41,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -51,7 +52,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -74,6 +74,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -84,7 +85,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: undefined;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
@@ -107,6 +107,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -117,7 +118,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;

package/dist/queries/useGetRequest.js

@@ -7,6 +7,7 @@ import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const [requestPath, setRequestPath] = useState(path);
@@ -15,6 +16,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     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, []);
@@ -52,7 +55,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         }
     };
     const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), {
-        enabled: load,
+        enabled: load && !isFutureQueriesPaused,
         ...options,
     });
     useEffect(() => {
@@ -112,12 +115,26 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        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]);
     return {
         ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
         setRequestPath,
         nextPage,
         prevPage,

package/dist/queries/useGetRequest.js.map

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