@ventlio/tanstack-query 0.2.85 → 0.2.87

package/dist/config/bootstrapQueryRequest.js

@@ -2,16 +2,18 @@ import 'url-search-params-polyfill';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
-    queryClient.setQueryDefaults(['config'], {
-        staleTime: Infinity,
-        cacheTime: Infinity,
-    });
     // set default query config
-    queryClient.setQueryData(['config'], {
+    const defaultMeta = {
         headers: {
             Authorization: ``,
         },
         options,
+    };
+    queryClient.setDefaultOptions({
+        queries: {
+            meta: defaultMeta,
+        },
+        mutations: { meta: defaultMeta },
     });
 };
 

package/dist/config/bootstrapQueryRequest.js.map

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

package/dist/config/useQueryConfig.js

@@ -2,8 +2,9 @@ import { useQueryClient } from '@tanstack/react-query';
 
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const { headers = {}, options = {} } = queryClient.getQueryData(['config']) ?? {};
-    return { headers, options };
+    const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
+    const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
+    return { ...queryMeta, ...mutationMeta };
 };
 
 export { useQueryConfig };

package/dist/config/useQueryConfig.js.map

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

package/dist/config/useQueryHeaders.js

@@ -1,24 +1,22 @@
 import { useQueryClient } from '@tanstack/react-query';
-import { getDateInFuture } from '../helpers/timeFuncs.js';
+import { useQueryConfig } from './useQueryConfig.js';
 
 const useQueryHeaders = () => {
     const queryClient = useQueryClient();
+    const { headers, options } = useQueryConfig();
     const getHeaders = () => {
-        const config = queryClient.getQueryData(['config']);
-        return config.headers;
+        return headers;
     };
     const setQueryHeaders = (newHeaders) => {
-        // make sure the config does not expire
-        queryClient.setQueryDefaults(['config'], {
-            staleTime: Infinity,
-            cacheTime: Infinity,
-        });
-        // set the config
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = { ...config, headers: newHeaders };
-            return newConfig;
-        }, {
-            updatedAt: getDateInFuture(2),
+        const defaultMeta = {
+            headers: { ...headers, ...newHeaders },
+            options,
+        };
+        queryClient.setDefaultOptions({
+            queries: {
+                meta: defaultMeta,
+            },
+            mutations: { meta: defaultMeta },
         });
     };
     return { setQueryHeaders, getHeaders };

package/dist/config/useQueryHeaders.js.map

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

package/dist/config/useReactNativeEnv.js

@@ -1,11 +1,10 @@
-import { useQueryClient } from '@tanstack/react-query';
+import { useQueryConfig } from './useQueryConfig.js';
 
 const useReactNativeEnv = () => {
-    const queryClient = useQueryClient();
-    const config = queryClient.getQueryData(['config']);
-    const appUrl = config?.options?.environments?.appBaseUrl;
-    const appTimeout = config?.options?.environments?.appTimeout;
-    const isApp = config?.options?.context === 'app';
+    const config = useQueryConfig();
+    const appUrl = config.options?.environments?.appBaseUrl;
+    const appTimeout = config.options?.environments?.appTimeout;
+    const isApp = config.options?.context === 'app';
     return { appUrl, appTimeout, isApp };
 };
 

package/dist/config/useReactNativeEnv.js.map

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

package/dist/index.mjs

@@ -7,25 +7,33 @@ import axios from 'axios';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
-    queryClient.setQueryDefaults(['config'], {
-        staleTime: Infinity,
-        cacheTime: Infinity,
-    });
     // set default query config
-    queryClient.setQueryData(['config'], {
+    const defaultMeta = {
         headers: {
             Authorization: ``,
         },
         options,
+    };
+    queryClient.setDefaultOptions({
+        queries: {
+            meta: defaultMeta,
+        },
+        mutations: { meta: defaultMeta },
     });
 };
 
-const useReactNativeEnv = () => {
+const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const config = queryClient.getQueryData(['config']);
-    const appUrl = config?.options?.environments?.appBaseUrl;
-    const appTimeout = config?.options?.environments?.appTimeout;
-    const isApp = config?.options?.context === 'app';
+    const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
+    const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
+    return { ...queryMeta, ...mutationMeta };
+};
+
+const useReactNativeEnv = () => {
+    const config = useQueryConfig();
+    const appUrl = config.options?.environments?.appBaseUrl;
+    const appTimeout = config.options?.environments?.appTimeout;
+    const isApp = config.options?.context === 'app';
     return { appUrl, appTimeout, isApp };
 };
 
@@ -39,10 +47,25 @@ const useEnvironmentVariables = () => {
     };
 };
 
-const useQueryConfig = () => {
+const useQueryHeaders = () => {
     const queryClient = useQueryClient();
-    const { headers = {}, options = {} } = queryClient.getQueryData(['config']) ?? {};
-    return { headers, options };
+    const { headers, options } = useQueryConfig();
+    const getHeaders = () => {
+        return headers;
+    };
+    const setQueryHeaders = (newHeaders) => {
+        const defaultMeta = {
+            headers: { ...headers, ...newHeaders },
+            options,
+        };
+        queryClient.setDefaultOptions({
+            queries: {
+                meta: defaultMeta,
+            },
+            mutations: { meta: defaultMeta },
+        });
+    };
+    return { setQueryHeaders, getHeaders };
 };
 
 const scrollToTop = () => {
@@ -61,29 +84,6 @@ function getDateInFuture(days) {
     return date.getTime();
 }
 
-const useQueryHeaders = () => {
-    const queryClient = useQueryClient();
-    const getHeaders = () => {
-        const config = queryClient.getQueryData(['config']);
-        return config.headers;
-    };
-    const setQueryHeaders = (newHeaders) => {
-        // make sure the config does not expire
-        queryClient.setQueryDefaults(['config'], {
-            staleTime: Infinity,
-            cacheTime: Infinity,
-        });
-        // set the config
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = { ...config, headers: newHeaders };
-            return newConfig;
-        }, {
-            updatedAt: getDateInFuture(2),
-        });
-    };
-    return { setQueryHeaders, getHeaders };
-};
-
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
@@ -104,6 +104,7 @@ const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
+    const config = useQueryConfig();
     const add = (data, position, path) => {
         let records = (findAll(path) ?? []);
         if (!position || position === 'end') {
@@ -159,7 +160,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         return queryClient.setQueryData(queryKey, newData);
     };
     const getModelConfig = () => {
-        const { options } = queryClient.getQueryData(['config']) ?? {};
+        const { options } = config;
         const { modelConfig } = options ?? {};
         return modelConfig;
     };
@@ -392,31 +393,42 @@ function getAppFiles(body, fileSelectors = []) {
 
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
-    const [requestPath, updateDeletePath] = useState('');
+    const [requestPath, setRequestPath] = useState('');
     const [options, setOptions] = useState();
+    const { options: queryConfigOptions } = useQueryConfig();
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, queryKey) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const [url] = (queryKey ?? []);
-        const postResponse = await makeRequest({
-            path: url ?? requestPath,
+        const [url] = queryKey;
+        const requestUrl = (url ?? requestPath);
+        const requestOptions = {
+            path: requestUrl,
             headers: { ...globalHeaders, ...headers },
-            method: HttpMethod.DELETE,
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
-        });
-        if (postResponse.status) {
-            res(postResponse);
+        };
+        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(postResponse);
+            rej(null);
         }
     };
     const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
-        return updateDeletePath(link);
+        return setRequestPath(link);
     };
     const setOptionsAsync = async (fetchOptions) => {
         return setOptions(fetchOptions);
@@ -435,26 +447,37 @@ const useDeleteRequest = (deleteOptions) => {
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
-    const [requestPath, updatePath] = useState(path);
+    const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, pageParam) => {
+    const sendRequest = async (res, rej, queryKey, pageParam) => {
         if (load) {
             // get request headers
             const globalHeaders = getHeaders();
-            const getResponse = await makeRequest({
+            const requestOptions = {
                 path: pageParam ?? requestPath,
                 headers: { ...globalHeaders, ...headers },
                 baseURL: baseUrl ?? API_URL,
                 timeout: TIMEOUT,
-            });
-            if (getResponse.status) {
-                res(getResponse);
+            };
+            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(getResponse);
+                rej(null);
             }
         }
         else {
@@ -472,7 +495,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath }) => new Promise((res, rej) => sendRequest(res, rej, pageParam)), {
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
         enabled: load,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -490,7 +513,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     useEffect(() => {
@@ -510,11 +533,12 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
 };
 
 const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const [requestPath, updatePath] = useState(path);
+    const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
+    const { options: queryConfigOptions } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -522,18 +546,29 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (load) {
             // get request headers
             const globalHeaders = getHeaders();
-            const [url] = (queryKey ?? []);
-            const getResponse = await makeRequest({
-                path: url ?? requestPath,
+            const [url] = queryKey;
+            const requestUrl = (url ?? requestPath);
+            const requestOptions = {
+                path: requestUrl,
                 headers: { ...globalHeaders, ...headers },
                 baseURL: baseUrl ?? API_URL,
                 timeout: TIMEOUT,
-            });
-            if (getResponse.status) {
-                res(getResponse);
+            };
+            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(getResponse);
+                rej(null);
             }
         }
         else {
@@ -546,7 +581,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     });
     useEffect(() => {
         if (path) {
-            updatePath(path);
+            setRequestPath(path);
         }
     }, [path]);
     useEffect(() => {
@@ -563,7 +598,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
             if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
-                updatePath(constructPaginationLink(requestPath, pagination.next_page));
+                setRequestPath(constructPaginationLink(requestPath, pagination.next_page));
             }
         }
     };
@@ -571,7 +606,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
             if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
-                updatePath(constructPaginationLink(requestPath, pagination.previous_page));
+                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
             }
         }
     };
@@ -588,11 +623,11 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         return link;
     };
     const gotoPage = (pageNumber) => {
-        updatePath(constructPaginationLink(requestPath, pageNumber));
+        setRequestPath(constructPaginationLink(requestPath, pageNumber));
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     const setOptionsAsync = async (fetchOptions) => {
@@ -607,7 +642,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
     return {
         ...query,
-        updatePath,
+        setRequestPath,
         nextPage,
         prevPage,
         get,
@@ -631,12 +666,11 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const { getHeaders } = useQueryHeaders();
-    const queryClient = useQueryClient();
-    const config = queryClient.getQueryData(['config']);
+    const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const patchResponse = await makeRequest({
+        const requestOptions = {
             path: path,
             body: data,
             method: HttpMethod.PATCH,
@@ -644,26 +678,39 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
             onUploadProgress,
-        });
-        if (patchResponse.status) {
-            // scroll to top after success
-            if (config?.options?.context !== 'app') {
-                scrollToTop();
+        };
+        let shouldContinue = true;
+        if (config.options?.mutationMiddleware) {
+            shouldContinue = await config.options.mutationMiddleware({
+                mutationKey: [path, { type: 'mutation' }],
+                ...requestOptions,
+            });
+        }
+        if (shouldContinue) {
+            const patchResponse = await makeRequest(requestOptions);
+            if (patchResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(patchResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(patchResponse);
             }
-            res(patchResponse);
         }
         else {
-            // scroll to top after error
-            if (config?.options?.context !== 'app') {
-                scrollToTop();
-            }
-            rej(patchResponse);
+            rej(null);
         }
     };
     // register post mutation
     const mutation = useMutation((dataData) => new Promise((res, rej) => {
         return sendRequest(res, rej, dataData);
-    }));
+    }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (data, options) => {
         return mutation.mutateAsync(data, options);
     };
@@ -672,17 +719,16 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const queryClient = useQueryClient();
+    const config = useQueryConfig();
     const { getHeaders } = useQueryHeaders();
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const sendRequest = async (res, rej, postData) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const config = queryClient.getQueryData(['config']);
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
-        const postResponse = await makeRequest({
+        const requestOptions = {
             path,
             body: data,
             method: HttpMethod.POST,
@@ -696,24 +742,39 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             },
             onUploadProgress,
             ...requestConfig,
-        });
-        if (postResponse.status) {
-            // scroll to top after success
-            if (config?.options?.context !== 'app') {
-                scrollToTop();
+        };
+        let shouldContinue = true;
+        if (config.options?.mutationMiddleware) {
+            shouldContinue = await config.options.mutationMiddleware({
+                mutationKey: [path, { type: 'mutation' }],
+                ...requestOptions,
+            });
+        }
+        if (shouldContinue) {
+            const postResponse = await makeRequest(requestOptions);
+            if (postResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(postResponse);
             }
-            res(postResponse);
         }
         else {
-            // scroll to top after error
-            if (config?.options?.context !== 'app') {
-                scrollToTop();
-            }
-            rej(postResponse);
+            rej(null);
         }
     };
     // register post mutation
-    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)));
+    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)), {
+        mutationKey: [path, { type: 'mutation' }],
+    });
     const post = async (data, options) => {
         const { requestConfig, ...otherOptions } = options ?? {};
         return mutation.mutateAsync({ data, requestConfig }, otherOptions);

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/model/useQueryModel.js

@@ -1,12 +1,15 @@
 import { useQueryClient } from '@tanstack/react-query';
 import result from 'lodash.result';
 import lodashSet from 'lodash.set';
+import 'url-search-params-polyfill';
+import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
 const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
+    const config = useQueryConfig();
     const add = (data, position, path) => {
         let records = (findAll(path) ?? []);
         if (!position || position === 'end') {
@@ -62,7 +65,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         return queryClient.setQueryData(queryKey, newData);
     };
     const getModelConfig = () => {
-        const { options } = queryClient.getQueryData(['config']) ?? {};
+        const { options } = config;
         const { modelConfig } = options ?? {};
         return modelConfig;
     };

package/dist/model/useQueryModel.js.map

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