@ventlio/tanstack-query 0.3.0 → 0.3.2

package/dist/model/useKeyTrackerModel.js

@@ -3,11 +3,7 @@ import { useQueryClient } from '@tanstack/react-query';
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
-        const meta = {
-            ...queryClient.getDefaultOptions().mutations?.meta,
-            ...queryClient.getDefaultOptions().queries?.meta,
-        };
-        const queryKey = meta[innerKeyTracker ?? keyTracker];
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
         return queryKey;
     };
     const refetchQuery = async (innerKeyTracker) => {

package/dist/model/useKeyTrackerModel.js.map

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

package/dist/queries/useDeleteRequest.d.ts

@@ -2,7 +2,7 @@ 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 | undefined;
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
@@ -31,7 +31,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
@@ -60,7 +60,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: any;
     isError: true;
@@ -89,7 +89,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;

package/dist/queries/useDeleteRequest.js

@@ -7,13 +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 [destroyConfig, setDestroyConfig] = 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) => {
@@ -28,7 +30,7 @@ const useDeleteRequest = (deleteOptions) => {
             timeout: TIMEOUT,
         };
         let shouldContinue = true;
-        if (queryConfigOptions.queryMiddleware) {
+        if (queryConfigOptions?.queryMiddleware) {
             shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
         }
         if (shouldContinue) {
@@ -52,7 +54,7 @@ const useDeleteRequest = (deleteOptions) => {
         return setOptions(fetchOptions);
     };
     const destroy = async (link, internalDeleteOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
             internalDeleteOptions = internalDeleteOptions ?? {};
             internalDeleteOptions.enabled = true;
@@ -61,19 +63,18 @@ const useDeleteRequest = (deleteOptions) => {
             return query.data;
         }
         else {
-            // save delete config
-            setDestroyConfig({ link, internalDeleteOptions });
+            setRequestPayload({ link, internalDeleteOptions });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && destroyConfig) {
-            destroy(destroyConfig.link, destroyConfig.internalDeleteOptions);
-            setDestroyConfig(undefined);
+        if (!isFutureQueriesPaused && requestPayload) {
+            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
-    return { destroy, ...query, isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries };
+    }, [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,7 +17,7 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     }> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: any;
     isError: true;
@@ -58,7 +58,7 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -99,7 +99,7 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;
@@ -142,7 +142,7 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;

package/dist/queries/useGetInfiniteRequest.js

@@ -7,14 +7,16 @@ 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();
     const { getHeaders } = useQueryHeaders();
     const [requestPath, setRequestPath] = useState(path);
-    const [queryConfig, setQueryConfig] = useState();
     const [options, setOptions] = useState(queryOptions);
-    const { options: queryConfigOptions, setConfig } = useQueryConfig();
+    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, []);
@@ -29,7 +31,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
                 timeout: TIMEOUT,
             };
             let shouldContinue = true;
-            if (queryConfigOptions.queryMiddleware) {
+            if (queryConfigOptions?.queryMiddleware) {
                 shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
             }
             if (shouldContinue) {
@@ -61,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 || !queryConfigOptions.pauseFutureQueries,
+        enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -72,16 +74,23 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             await setOptionsAsync(fetchOptions);
             await updatedPathAsync(link);
             return query.data;
         }
         else {
-            setQueryConfig({ link, fetchOptions });
+            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);
@@ -89,21 +98,18 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     };
     useEffect(() => {
         if (keyTracker) {
-            setConfig({ [keyTracker]: [requestPath, {}] });
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [keyTracker, requestPath]);
-    useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
-            get(queryConfig.link, queryConfig.fetchOptions);
-            setQueryConfig(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
     return {
         get,
         ...query,
-        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
+        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,7 +8,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     queryOptions?: TanstackQueryOption<TResponse> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -41,7 +41,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -74,7 +74,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -107,7 +107,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;

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);
@@ -14,8 +15,9 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
-    const { options: queryConfigOptions, setConfig } = useQueryConfig();
-    const [queryConfig, setQueryConfig] = useState();
+    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, []);
@@ -32,7 +34,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
                 timeout: TIMEOUT,
             };
             let shouldContinue = true;
-            if (queryConfigOptions.queryMiddleware) {
+            if (queryConfigOptions?.queryMiddleware) {
                 shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
             }
             if (shouldContinue) {
@@ -53,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(() => {
@@ -63,10 +65,14 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     }, [path]);
     useEffect(() => {
         if (keyTracker) {
-            setConfig({ [keyTracker]: [requestPath, {}] });
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [keyTracker, requestPath]);
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
     const nextPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
@@ -109,26 +115,26 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             await setOptionsAsync(fetchOptions);
             await updatedPathAsync(link);
             return query.data;
         }
         else {
-            setQueryConfig({ link, fetchOptions });
+            setRequestPayload({ link, fetchOptions });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
-            get(queryConfig.link, queryConfig.fetchOptions);
-            setQueryConfig(undefined);
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
+    }, [isFutureQueriesPaused]);
     return {
         ...query,
-        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
+        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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/usePatchRequest.d.ts

@@ -4,7 +4,7 @@ import type { DefaultRequestOptions } from './queries.interface';
 export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     path: string;
 } & DefaultRequestOptions) => {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -22,7 +22,7 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -40,7 +40,7 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: undefined;
     error: IRequestError;
     isError: true;
@@ -58,7 +58,7 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
-    isLoading: boolean | undefined;
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;

package/dist/queries/usePatchRequest.js

@@ -9,11 +9,13 @@ import { useUploadProgress } from '../hooks/useUploadProgress.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
-    const [mutationConfig, setMutationConfig] = useState();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
@@ -29,7 +31,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             onUploadProgress,
         };
         let shouldContinue = true;
-        if (config.options.mutationMiddleware) {
+        if (config.options?.mutationMiddleware) {
             shouldContinue = await config.options.mutationMiddleware({
                 mutationKey: [path, { type: 'mutation' }],
                 ...requestOptions,
@@ -39,14 +41,14 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             const patchResponse = await makeRequest(requestOptions);
             if (patchResponse.status) {
                 // scroll to top after success
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 res(patchResponse);
             }
             else {
                 // scroll to top after error
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 rej(patchResponse);
@@ -61,27 +63,22 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         return sendRequest(res, rej, dataData);
     }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (data, options) => {
-        if (!config.options.pauseFutureMutations) {
+        if (!isFutureMutationsPaused) {
             return mutation.mutateAsync(data, options);
         }
         else {
-            setMutationConfig({ data, options });
+            setRequestPayload({ data, options });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!config.options.pauseFutureMutations && mutationConfig) {
-            patch(mutationConfig.data, mutationConfig.options);
-            setMutationConfig(undefined);
+        if (!isFutureMutationsPaused && requestPayload) {
+            patch(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [config.options.pauseFutureMutations]);
-    return {
-        patch,
-        uploadProgressPercent,
-        ...mutation,
-        isLoading: mutation.isLoading || config.options.pauseFutureMutations,
-    };
+    }, [isFutureMutationsPaused]);
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
 export { usePatchRequest };

package/dist/queries/usePatchRequest.js.map

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

package/dist/queries/usePostRequest.d.ts

@@ -6,11 +6,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     isFormData?: boolean | undefined;
     fileSelectors?: string[] | undefined;
 } & DefaultRequestOptions) => {
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
     isIdle: true;
-    isLoading: false;
     isSuccess: false;
     status: "idle";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
@@ -42,11 +42,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean;
     data: undefined;
     error: null;
     isError: false;
     isIdle: false;
-    isLoading: true;
     isSuccess: false;
     status: "loading";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
@@ -78,11 +78,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean;
     data: undefined;
     error: IRequestError;
     isError: true;
     isIdle: false;
-    isLoading: false;
     isSuccess: false;
     status: "error";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
@@ -114,11 +114,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
     isIdle: false;
-    isLoading: false;
     isSuccess: true;
     status: "success";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {

package/dist/queries/usePostRequest.js

@@ -10,14 +10,16 @@ import { useUploadProgress } from '../hooks/useUploadProgress.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const config = useQueryConfig();
-    const [mutationConfig, setMutationConfig] = useState();
     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();
@@ -39,7 +41,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             ...requestConfig,
         };
         let shouldContinue = true;
-        if (config.options.mutationMiddleware) {
+        if (config.options?.mutationMiddleware) {
             shouldContinue = await config.options.mutationMiddleware({
                 mutationKey: [path, { type: 'mutation' }],
                 ...requestOptions,
@@ -49,14 +51,14 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             const postResponse = await makeRequest(requestOptions);
             if (postResponse.status) {
                 // scroll to top after success
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 res(postResponse);
             }
             else {
                 // scroll to top after error
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 rej(postResponse);
@@ -71,23 +73,23 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
-        if (!config.options.pauseFutureMutations) {
+        if (!isFutureMutationsPaused) {
             const { requestConfig, ...otherOptions } = options ?? {};
             return mutation.mutateAsync({ data, requestConfig }, otherOptions);
         }
         else {
-            setMutationConfig({ data, options });
+            setRequestPayload({ data, options });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!config.options.pauseFutureMutations && mutationConfig) {
-            post(mutationConfig.data, mutationConfig.options);
-            setMutationConfig(undefined);
+        if (!isFutureMutationsPaused && requestPayload) {
+            post(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [config.options.pauseFutureMutations]);
-    return { post, uploadProgressPercent, ...mutation };
+    }, [isFutureMutationsPaused]);
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
 export { usePostRequest };

package/dist/queries/usePostRequest.js.map

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

package/dist/stores/index.d.ts

@@ -0,0 +1 @@
+export * from './usePauseFutureRequests';

package/dist/stores/usePauseFutureRequests.d.ts

@@ -0,0 +1,7 @@
+export interface PauseFutureRequest {
+    isFutureQueriesPaused: boolean;
+    isFutureMutationsPaused: boolean;
+    pauseFutureMutation: (status: boolean) => void;
+    pauseFutureQueries: (status: boolean) => void;
+}
+export declare const usePauseFutureRequests: import("zustand").UseBoundStore<import("zustand").StoreApi<PauseFutureRequest>>;