@ventlio/tanstack-query 0.2.62 → 0.2.63-beta.2

package/dist/config/bootstrapQueryRequest.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
     queryClient.setQueryDefaults(['config'], {
@@ -15,5 +13,5 @@ const bootstrapQueryRequest = (queryClient, options) => {
     });
 };
 
-exports.bootstrapQueryRequest = bootstrapQueryRequest;
+export { bootstrapQueryRequest };
 //# sourceMappingURL=bootstrapQueryRequest.js.map

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/useEnvironmentVariables.js

@@ -1,16 +1,14 @@
-'use strict';
-
-var useReactNativeEnv = require('./useReactNativeEnv.js');
+import { useReactNativeEnv } from './useReactNativeEnv.js';
 
 const useEnvironmentVariables = () => {
-    const { appTimeout, appUrl } = useReactNativeEnv.useReactNativeEnv();
-    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
-    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
+    const { appTimeout, appUrl } = useReactNativeEnv();
+    const url = process.env.REACT_APP_API_URL ?? process.env.NEXT_PUBLIC_API_URL ?? appUrl;
+    const timeout = process.env.REACT_APP_API_TIMEOUT ?? process.env.NEXT_PUBLIC_API_TIMEOUT ?? appTimeout;
     return {
         API_URL: url,
         TIMEOUT: Number(timeout),
     };
 };
 
-exports.useEnvironmentVariables = useEnvironmentVariables;
+export { useEnvironmentVariables };
 //# sourceMappingURL=useEnvironmentVariables.js.map

package/dist/config/useEnvironmentVariables.js.map

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

package/dist/config/useQueryConfig.js

@@ -1,12 +1,10 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
+import { useQueryClient } from '@tanstack/react-query';
 
 const useQueryConfig = () => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const { headers = {} } = queryClient.getQueryData(['config']) ?? {};
     return { headers };
 };
 
-exports.useQueryConfig = useQueryConfig;
+export { useQueryConfig };
 //# sourceMappingURL=useQueryConfig.js.map

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,10 +1,8 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var timeFuncs = require('../helpers/timeFuncs.js');
+import { useQueryClient } from '@tanstack/react-query';
+import { getDateInFuture } from '../helpers/timeFuncs.js';
 
 const useQueryHeaders = () => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const getHeaders = () => {
         const config = queryClient.getQueryData(['config']);
         return config.headers;
@@ -20,11 +18,11 @@ const useQueryHeaders = () => {
             const newConfig = { ...config, headers: newHeaders };
             return newConfig;
         }, {
-            updatedAt: timeFuncs.getDateInFuture(2),
+            updatedAt: getDateInFuture(2),
         });
     };
     return { setQueryHeaders, getHeaders };
 };
 
-exports.useQueryHeaders = useQueryHeaders;
+export { useQueryHeaders };
 //# sourceMappingURL=useQueryHeaders.js.map

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.d.ts

@@ -1,4 +1,5 @@
 export declare const useReactNativeEnv: () => {
     appUrl: string | undefined;
     appTimeout: number | undefined;
+    isApp: boolean;
 };

package/dist/config/useReactNativeEnv.js

@@ -1,26 +1,13 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var react = require('react');
+import { useQueryClient } from '@tanstack/react-query';
 
 const useReactNativeEnv = () => {
-    const queryClient = reactQuery.useQueryClient();
-    const [appUrl, setAppUrl] = react.useState(undefined);
-    const [appTimeout, setAppTimeout] = react.useState();
-    react.useEffect(() => {
-        const config = queryClient.getQueryData(['config']);
-        const loadReactNativeEnvIfNeeded = async () => {
-            if (config?.options?.context === 'app') {
-                const API_URL = config.options.environments?.appBaseUrl;
-                const API_TIMEOUT = config.options.environments?.appTimeout;
-                setAppUrl(API_URL);
-                setAppTimeout(API_TIMEOUT);
-            }
-        };
-        loadReactNativeEnvIfNeeded();
-    }, [queryClient]);
-    return { appUrl, appTimeout };
+    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';
+    return { appUrl, appTimeout, isApp };
 };
 
-exports.useReactNativeEnv = useReactNativeEnv;
+export { useReactNativeEnv };
 //# sourceMappingURL=useReactNativeEnv.js.map

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/helpers/scrollToTop.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const scrollToTop = () => {
     window.scrollTo({
         top: 0,
@@ -7,5 +5,5 @@ const scrollToTop = () => {
     });
 };
 
-exports.scrollToTop = scrollToTop;
+export { scrollToTop };
 //# sourceMappingURL=scrollToTop.js.map

package/dist/helpers/scrollToTop.js.map

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

package/dist/helpers/timeFuncs.js

@@ -1,5 +1,3 @@
-'use strict';
-
 function getDateInFuture(days) {
     // Create a new Date object
     const date = new Date();
@@ -9,5 +7,5 @@ function getDateInFuture(days) {
     return date.getTime();
 }
 
-exports.getDateInFuture = getDateInFuture;
+export { getDateInFuture };
 //# sourceMappingURL=timeFuncs.js.map

package/dist/helpers/timeFuncs.js.map

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

package/dist/index.js

@@ -1,52 +1,20 @@
-'use strict';
-
-var bootstrapQueryRequest = require('./config/bootstrapQueryRequest.js');
-var useEnvironmentVariables = require('./config/useEnvironmentVariables.js');
-var useQueryConfig = require('./config/useQueryConfig.js');
-var useQueryHeaders = require('./config/useQueryHeaders.js');
-var useReactNativeEnv = require('./config/useReactNativeEnv.js');
-var scrollToTop = require('./helpers/scrollToTop.js');
-var timeFuncs = require('./helpers/timeFuncs.js');
-var useKeyTrackerModel = require('./model/useKeyTrackerModel.js');
-var useQueryModel = require('./model/useQueryModel.js');
-var useRefetchQuery = require('./model/useRefetchQuery.js');
-var useDeleteRequest = require('./queries/useDeleteRequest.js');
-var useGetRequest = require('./queries/useGetRequest.js');
-var usePatchRequest = require('./queries/usePatchRequest.js');
-var usePostRequest = require('./queries/usePostRequest.js');
-var axiosInstance = require('./request/axios-instance.js');
-var buildFormData = require('./request/buildFormData.js');
-var makeRequest = require('./request/make-request.js');
-var request_enum = require('./request/request.enum.js');
-var transformer = require('./request/transformer.js');
-
-
-
-exports.bootstrapQueryRequest = bootstrapQueryRequest.bootstrapQueryRequest;
-exports.useEnvironmentVariables = useEnvironmentVariables.useEnvironmentVariables;
-exports.useQueryConfig = useQueryConfig.useQueryConfig;
-exports.useQueryHeaders = useQueryHeaders.useQueryHeaders;
-exports.useReactNativeEnv = useReactNativeEnv.useReactNativeEnv;
-exports.scrollToTop = scrollToTop.scrollToTop;
-exports.getDateInFuture = timeFuncs.getDateInFuture;
-exports.useKeyTrackerModel = useKeyTrackerModel.useKeyTrackerModel;
-exports.useQueryModel = useQueryModel.useQueryModel;
-exports.useRefetchQuery = useRefetchQuery.useRefetchQuery;
-exports.useDeleteRequest = useDeleteRequest.useDeleteRequest;
-exports.useGetRequest = useGetRequest.useGetRequest;
-exports.usePatchRequest = usePatchRequest.usePatchRequest;
-exports.usePostRequest = usePostRequest.usePostRequest;
-exports.axiosInstance = axiosInstance.axiosInstance;
-exports.buildFormData = buildFormData.buildFormData;
-exports.makeRequest = makeRequest.makeRequest;
-Object.defineProperty(exports, 'ContentType', {
-	enumerable: true,
-	get: function () { return request_enum.ContentType; }
-});
-Object.defineProperty(exports, 'HttpMethod', {
-	enumerable: true,
-	get: function () { return request_enum.HttpMethod; }
-});
-exports.errorTransformer = transformer.errorTransformer;
-exports.successTransformer = transformer.successTransformer;
+export { bootstrapQueryRequest } from './config/bootstrapQueryRequest.js';
+export { useEnvironmentVariables } from './config/useEnvironmentVariables.js';
+export { useQueryConfig } from './config/useQueryConfig.js';
+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 { useKeyTrackerModel } from './model/useKeyTrackerModel.js';
+export { useQueryModel } from './model/useQueryModel.js';
+export { useRefetchQuery } from './model/useRefetchQuery.js';
+export { useDeleteRequest } from './queries/useDeleteRequest.js';
+export { useGetRequest } from './queries/useGetRequest.js';
+export { usePatchRequest } from './queries/usePatchRequest.js';
+export { usePostRequest } from './queries/usePostRequest.js';
+export { axiosInstance } from './request/axios-instance.js';
+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';
 //# 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,6 +1,6 @@
 import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
-import { useState, useEffect, useMemo, startTransition } from 'react';
-import { Axios } from 'axios';
+import { useState, useMemo, useEffect, startTransition } from 'react';
+import axios from 'axios';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
@@ -19,27 +19,17 @@ const bootstrapQueryRequest = (queryClient, options) => {
 
 const useReactNativeEnv = () => {
     const queryClient = useQueryClient();
-    const [appUrl, setAppUrl] = useState(undefined);
-    const [appTimeout, setAppTimeout] = useState();
-    useEffect(() => {
-        const config = queryClient.getQueryData(['config']);
-        const loadReactNativeEnvIfNeeded = async () => {
-            if (config?.options?.context === 'app') {
-                const API_URL = config.options.environments?.appBaseUrl;
-                const API_TIMEOUT = config.options.environments?.appTimeout;
-                setAppUrl(API_URL);
-                setAppTimeout(API_TIMEOUT);
-            }
-        };
-        loadReactNativeEnvIfNeeded();
-    }, [queryClient]);
-    return { appUrl, appTimeout };
+    const config = queryClient.getQueryData(['config']);
+    const appUrl = config?.options?.environments?.appBaseUrl;
+    const appTimeout = config?.options?.environments?.appTimeout;
+    const isApp = config?.options?.context === 'app';
+    return { appUrl, appTimeout, isApp };
 };
 
 const useEnvironmentVariables = () => {
     const { appTimeout, appUrl } = useReactNativeEnv();
-    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
-    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
+    const url = process.env.REACT_APP_API_URL ?? process.env.NEXT_PUBLIC_API_URL ?? appUrl;
+    const timeout = process.env.REACT_APP_API_TIMEOUT ?? process.env.NEXT_PUBLIC_API_TIMEOUT ?? appTimeout;
     return {
         API_URL: url,
         TIMEOUT: Number(timeout),
@@ -124,10 +114,12 @@ const useRefetchQuery = async (queryKey) => {
     return { refetchQuery };
 };
 
-const axiosInstance = (method) => {
-    const axiosI = new Axios();
-    const requestMethod = method.toLowerCase();
-    return axiosI[requestMethod];
+const axiosInstance = ({ baseURL, timeout, headers }) => {
+    return axios.create({
+        baseURL,
+        timeout,
+        headers,
+    });
 };
 
 const buildFormData = (body) => {
@@ -209,7 +201,7 @@ const successTransformer = (data) => {
 
 async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, }) {
     // configure body
-    body = isFormData ? buildFormData(body) : body;
+    body = isFormData ? axios.toFormData(body) : body;
     // configure request header
     if (!isFormData) {
         headers['Content-Type'] = ContentType.APPLICATION_JSON;
@@ -218,9 +210,13 @@ async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, he
         delete headers['Content-Type'];
     }
     try {
-        const axios = axiosInstance(method);
+        const axios = axiosInstance({ baseURL, headers, timeout });
         //   send request
-        const resp = await axios(path, { baseURL, headers, timeout });
+        const resp = await axios({
+            url: path,
+            method,
+            data: body,
+        });
         // get response json
         const jsonResp = await resp.data;
         // get response code

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/useKeyTrackerModel.js

@@ -1,9 +1,7 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
+import { useQueryClient } from '@tanstack/react-query';
 
 const useKeyTrackerModel = (keyTracker) => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
         const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
         return queryKey;
@@ -18,5 +16,5 @@ const useKeyTrackerModel = (keyTracker) => {
     return { refetchQuery, getQueryKey };
 };
 
-exports.useKeyTrackerModel = useKeyTrackerModel;
+export { useKeyTrackerModel };
 //# sourceMappingURL=useKeyTrackerModel.js.map

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

@@ -1,11 +1,9 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
+import { useQueryClient } from '@tanstack/react-query';
 
 const useQueryModel = (queryKey, filters) => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     return queryClient.getQueryData(queryKey, filters);
 };
 
-exports.useQueryModel = useQueryModel;
+export { useQueryModel };
 //# sourceMappingURL=useQueryModel.js.map

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

package/dist/model/useRefetchQuery.js

@@ -1,9 +1,7 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
+import { useQueryClient } from '@tanstack/react-query';
 
 const useRefetchQuery = async (queryKey) => {
-    const queryClient = reactQuery.useQueryClient();
+    const queryClient = useQueryClient();
     const refetchQuery = async (innerQueryKey) => {
         await queryClient.refetchQueries({
             queryKey,
@@ -14,5 +12,5 @@ const useRefetchQuery = async (queryKey) => {
     return { refetchQuery };
 };
 
-exports.useRefetchQuery = useRefetchQuery;
+export { useRefetchQuery };
 //# sourceMappingURL=useRefetchQuery.js.map

package/dist/model/useRefetchQuery.js.map

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

package/dist/queries/useDeleteRequest.js

@@ -1,26 +1,24 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var react = require('react');
-var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
-var useQueryHeaders = require('../config/useQueryHeaders.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-var request_enum = require('../request/request.enum.js');
+import { useQuery } from '@tanstack/react-query';
+import { useState } from 'react';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+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, updateDeletePath] = react.useState('');
-    const [options, setOptions] = react.useState();
-    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders.useQueryHeaders();
+    const [requestPath, updateDeletePath] = useState('');
+    const [options, setOptions] = useState();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const postResponse = await makeRequest.makeRequest({
+        const postResponse = await makeRequest({
             path: requestPath,
             headers: { ...globalHeaders, ...headers },
-            method: request_enum.HttpMethod.DELETE,
+            method: HttpMethod.DELETE,
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
         });
@@ -31,7 +29,7 @@ const useDeleteRequest = (deleteOptions) => {
             rej(postResponse);
         }
     };
-    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), { enabled: false, ...options });
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
         return updateDeletePath(link);
     };
@@ -49,5 +47,5 @@ const useDeleteRequest = (deleteOptions) => {
     return { destroy, ...query };
 };
 
-exports.useDeleteRequest = useDeleteRequest;
+export { useDeleteRequest };
 //# sourceMappingURL=useDeleteRequest.js.map

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/useGetRequest.js

@@ -1,26 +1,24 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var react = require('react');
-var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
-var useQueryHeaders = require('../config/useQueryHeaders.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-require('../request/request.enum.js');
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { useState, useMemo, useEffect, startTransition } from 'react';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import '../request/request.enum.js';
 
 const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const [requestPath, updatePath] = react.useState(path);
-    const [options, setOptions] = react.useState(queryOptions);
-    const [page, setPage] = react.useState(1);
-    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders.useQueryHeaders();
-    let queryClient = reactQuery.useQueryClient();
+    const [requestPath, updatePath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const [page, setPage] = useState(1);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
+    let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    queryClient = react.useMemo(() => queryClient, []);
+    queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const getResponse = await makeRequest.makeRequest({
+        const getResponse = await makeRequest({
             path: requestPath,
             headers: { ...globalHeaders, ...headers },
             baseURL: baseUrl ?? API_URL,
@@ -33,16 +31,16 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
             rej(getResponse);
         }
     };
-    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), {
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), {
         enabled: load,
         ...options,
     });
-    react.useEffect(() => {
+    useEffect(() => {
         if (path) {
             updatePath(path);
         }
     }, [path]);
-    react.useEffect(() => {
+    useEffect(() => {
         if (keyTracker) {
             // set expiration time for the tracker
             queryClient.setQueryDefaults([keyTracker], {
@@ -84,12 +82,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         updatePath(constructPaginationLink(requestPath, pageNumber));
     };
     const updatedPathAsync = async (link) => {
-        react.startTransition(() => {
+        startTransition(() => {
             updatePath(link);
         });
     };
     const setOptionsAsync = async (fetchOptions) => {
-        react.startTransition(() => {
+        startTransition(() => {
             setOptions(fetchOptions);
         });
     };
@@ -110,5 +108,5 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
 };
 
-exports.useGetRequest = useGetRequest;
+export { useGetRequest };
 //# sourceMappingURL=useGetRequest.js.map

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.js

@@ -1,41 +1,38 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
-var useQueryHeaders = require('../config/useQueryHeaders.js');
-require('react');
-var scrollToTop = require('../helpers/scrollToTop.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-var request_enum = require('../request/request.enum.js');
+import { useMutation } from '@tanstack/react-query';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { scrollToTop } from '../helpers/scrollToTop.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import { HttpMethod } from '../request/request.enum.js';
 
 const usePatchRequest = ({ path, baseUrl, headers }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders.useQueryHeaders();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const patchResponse = await makeRequest.makeRequest({
+        const patchResponse = await makeRequest({
             path: path,
             body: data,
-            method: request_enum.HttpMethod.PATCH,
+            method: HttpMethod.PATCH,
             headers: { ...globalHeaders, ...headers },
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
         });
         if (patchResponse.status) {
             // scroll to top after success
-            scrollToTop.scrollToTop();
+            scrollToTop();
             res(patchResponse);
         }
         else {
             // scroll to top after error
-            scrollToTop.scrollToTop();
+            scrollToTop();
             rej(patchResponse);
         }
     };
     // register post mutation
-    const mutation = reactQuery.useMutation((dataData) => new Promise((res, rej) => {
+    const mutation = useMutation((dataData) => new Promise((res, rej) => {
         return sendRequest(res, rej, dataData);
     }));
     const patch = async (data, options) => {
@@ -44,5 +41,5 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     return { patch, ...mutation };
 };
 
-exports.usePatchRequest = usePatchRequest;
+export { usePatchRequest };
 //# sourceMappingURL=usePatchRequest.js.map

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.js

@@ -1,26 +1,23 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
-var useQueryHeaders = require('../config/useQueryHeaders.js');
-require('react');
-var scrollToTop = require('../helpers/scrollToTop.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-var request_enum = require('../request/request.enum.js');
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { scrollToTop } from '../helpers/scrollToTop.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import { HttpMethod } from '../request/request.enum.js';
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
-    const queryClient = reactQuery.useQueryClient();
-    const { getHeaders } = useQueryHeaders.useQueryHeaders();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const queryClient = useQueryClient();
+    const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, postData) => {
         // get request headers
         const globalHeaders = getHeaders();
         const config = queryClient.getQueryData(['config']);
-        const postResponse = await makeRequest.makeRequest({
+        const postResponse = await makeRequest({
             path,
             body: postData,
-            method: request_enum.HttpMethod.POST,
+            method: HttpMethod.POST,
             isFormData,
             headers: { ...globalHeaders, ...headers },
             baseURL: baseUrl ?? API_URL,
@@ -29,25 +26,25 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, }) => {
         if (postResponse.status) {
             // scroll to top after success
             if (config?.options?.context !== 'app') {
-                scrollToTop.scrollToTop();
+                scrollToTop();
             }
             res(postResponse);
         }
         else {
             // scroll to top after error
             if (config?.options?.context !== 'app') {
-                scrollToTop.scrollToTop();
+                scrollToTop();
             }
             rej(postResponse);
         }
     };
     // register post mutation
-    const mutation = reactQuery.useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)));
+    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)));
     const post = async (data, options) => {
         return mutation.mutateAsync(data, options);
     };
     return { post, ...mutation };
 };
 
-exports.usePostRequest = usePostRequest;
+export { usePostRequest };
 //# sourceMappingURL=usePostRequest.js.map

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/request/axios-instance.d.ts

@@ -1,2 +1,3 @@
-import type { HttpMethod } from './request.enum';
-export declare const axiosInstance: (method: HttpMethod) => (<T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, config?: import("axios").AxiosRequestConfig<D> | undefined) => Promise<R>) | (<T_1 = any, R_1 = import("axios").AxiosResponse<T_1, any>, D_1 = any>(url: string, data?: D_1 | undefined, config?: import("axios").AxiosRequestConfig<D_1> | undefined) => Promise<R_1>) | (<T_2 = any, R_2 = import("axios").AxiosResponse<T_2, any>, D_2 = any>(url: string, data?: D_2 | undefined, config?: import("axios").AxiosRequestConfig<D_2> | undefined) => Promise<R_2>) | (<T_3 = any, R_3 = import("axios").AxiosResponse<T_3, any>, D_3 = any>(url: string, data?: D_3 | undefined, config?: import("axios").AxiosRequestConfig<D_3> | undefined) => Promise<R_3>) | (<T_4 = any, R_4 = import("axios").AxiosResponse<T_4, any>, D_4 = any>(url: string, config?: import("axios").AxiosRequestConfig<D_4> | undefined) => Promise<R_4>);
+import type { AxiosInstance } from 'axios';
+import type { IMakeRequest } from './request.interface';
+export declare const axiosInstance: ({ baseURL, timeout, headers }: Partial<IMakeRequest>) => AxiosInstance;

package/dist/request/axios-instance.js

@@ -1,12 +1,12 @@
-'use strict';
+import axios from 'axios';
 
-var axios = require('axios');
-
-const axiosInstance = (method) => {
-    const axiosI = new axios.Axios();
-    const requestMethod = method.toLowerCase();
-    return axiosI[requestMethod];
+const axiosInstance = ({ baseURL, timeout, headers }) => {
+    return axios.create({
+        baseURL,
+        timeout,
+        headers,
+    });
 };
 
-exports.axiosInstance = axiosInstance;
+export { axiosInstance };
 //# sourceMappingURL=axios-instance.js.map

package/dist/request/buildFormData.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const buildFormData = (body) => {
     const formData = new FormData();
     const handleArrayValue = (key, value) => {
@@ -42,5 +40,5 @@ const buildFormData = (body) => {
     return formData;
 };
 
-exports.buildFormData = buildFormData;
+export { buildFormData };
 //# sourceMappingURL=buildFormData.js.map

package/dist/request/buildFormData.js.map

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

package/dist/request/make-request.js

@@ -1,33 +1,35 @@
-'use strict';
+import axios from 'axios';
+import { axiosInstance } from './axios-instance.js';
+import { ContentType, HttpMethod } from './request.enum.js';
+import { errorTransformer, successTransformer } from './transformer.js';
 
-var axiosInstance = require('./axios-instance.js');
-var buildFormData = require('./buildFormData.js');
-var request_enum = require('./request.enum.js');
-var transformer = require('./transformer.js');
-
-async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, }) {
+async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, }) {
     // configure body
-    body = isFormData ? buildFormData.buildFormData(body) : body;
+    body = isFormData ? axios.toFormData(body) : body;
     // configure request header
     if (!isFormData) {
-        headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
+        headers['Content-Type'] = ContentType.APPLICATION_JSON;
     }
     else {
         delete headers['Content-Type'];
     }
     try {
-        const axios = axiosInstance.axiosInstance(method);
+        const axios = axiosInstance({ baseURL, headers, timeout });
         //   send request
-        const resp = await axios(path, { baseURL, headers, timeout });
+        const resp = await axios({
+            url: path,
+            method,
+            data: body,
+        });
         // get response json
         const jsonResp = await resp.data;
         // get response code
         const responseCode = resp.status;
         if (responseCode > 299) {
             // server returned an error
-            return transformer.errorTransformer({ ...jsonResp, statusCode: responseCode });
+            return errorTransformer({ ...jsonResp, statusCode: responseCode });
         }
-        return transformer.successTransformer({
+        return successTransformer({
             statusCode: responseCode,
             ...jsonResp,
             status: resp.status,
@@ -35,7 +37,7 @@ async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, i
     }
     catch (error) {
         const errorData = error?.response?.data;
-        return transformer.errorTransformer({
+        return errorTransformer({
             statusCode: error.status,
             message: error.message,
             code: error.status || error.statusCode,
@@ -44,5 +46,5 @@ async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, i
     }
 }
 
-exports.makeRequest = makeRequest;
+export { makeRequest };
 //# sourceMappingURL=make-request.js.map

package/dist/request/make-request.js.map

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

package/dist/request/request.enum.js

@@ -1,16 +1,16 @@
-'use strict';
-
-exports.HttpMethod = void 0;
+var HttpMethod;
 (function (HttpMethod) {
     HttpMethod["GET"] = "GET";
     HttpMethod["POST"] = "POST";
     HttpMethod["PUT"] = "PUT";
     HttpMethod["PATCH"] = "PATCH";
     HttpMethod["DELETE"] = "DELETE";
-})(exports.HttpMethod || (exports.HttpMethod = {}));
-exports.ContentType = void 0;
+})(HttpMethod || (HttpMethod = {}));
+var ContentType;
 (function (ContentType) {
     ContentType["APPLICATION_JSON"] = "application/json";
     ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
-})(exports.ContentType || (exports.ContentType = {}));
+})(ContentType || (ContentType = {}));
+
+export { ContentType, HttpMethod };
 //# sourceMappingURL=request.enum.js.map

package/dist/request/transformer.js

@@ -1,5 +1,3 @@
-'use strict';
-
 //
 const errorTransformer = (data) => {
     return {
@@ -21,6 +19,5 @@ const successTransformer = (data) => {
     };
 };
 
-exports.errorTransformer = errorTransformer;
-exports.successTransformer = successTransformer;
+export { errorTransformer, successTransformer };
 //# sourceMappingURL=transformer.js.map

package/dist/request/transformer.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.62",
+  "version": "0.2.63-beta.2",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [

package/src/config/useEnvironmentVariables.ts

@@ -3,8 +3,8 @@ import { useReactNativeEnv } from './useReactNativeEnv';
 
 export const useEnvironmentVariables = (): IConfig => {
   const { appTimeout, appUrl } = useReactNativeEnv();
-  const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
-  const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
+  const url = process.env.REACT_APP_API_URL ?? process.env.NEXT_PUBLIC_API_URL ?? appUrl;
+  const timeout = process.env.REACT_APP_API_TIMEOUT ?? process.env.NEXT_PUBLIC_API_TIMEOUT ?? appTimeout;
 
   return {
     API_URL: url as string,

package/src/config/useReactNativeEnv.ts

@@ -1,28 +1,13 @@
 import { useQueryClient } from '@tanstack/react-query';
-import { useEffect, useState } from 'react';
 import type { TanstackQueryConfig } from '../types';
 
 export const useReactNativeEnv = () => {
   const queryClient = useQueryClient();
+  const config = queryClient.getQueryData<TanstackQueryConfig>(['config']);
 
-  const [appUrl, setAppUrl] = useState<string | undefined>(undefined);
-  const [appTimeout, setAppTimeout] = useState<number | undefined>();
+  const appUrl: string | undefined = config?.options?.environments?.appBaseUrl;
+  const appTimeout: number | undefined = config?.options?.environments?.appTimeout;
+  const isApp = config?.options?.context === 'app';
 
-  useEffect(() => {
-    const config = queryClient.getQueryData<TanstackQueryConfig>(['config']);
-
-    const loadReactNativeEnvIfNeeded = async () => {
-      if (config?.options?.context === 'app') {
-        const API_URL = config.options.environments?.appBaseUrl;
-        const API_TIMEOUT = config.options.environments?.appTimeout;
-
-        setAppUrl(API_URL);
-        setAppTimeout(API_TIMEOUT);
-      }
-    };
-
-    loadReactNativeEnvIfNeeded();
-  }, [queryClient]);
-
-  return { appUrl, appTimeout };
+  return { appUrl, appTimeout, isApp };
 };

package/src/request/axios-instance.ts

@@ -1,10 +1,11 @@
-import { Axios } from 'axios';
-import type { HttpMethod } from './request.enum';
+import type { AxiosInstance } from 'axios';
+import axios from 'axios';
+import type { IMakeRequest } from './request.interface';
 
-export const axiosInstance = (method: HttpMethod) => {
-  const axiosI = new Axios();
-
-  const requestMethod = method.toLowerCase() as Lowercase<HttpMethod>;
-
-  return axiosI[requestMethod];
+export const axiosInstance = ({ baseURL, timeout, headers }: Partial<IMakeRequest>): AxiosInstance => {
+  return axios.create({
+    baseURL,
+    timeout,
+    headers,
+  });
 };

package/src/request/make-request.ts

@@ -1,6 +1,6 @@
+import axios from 'axios';
 import { axiosInstance } from './axios-instance';
 
-import { buildFormData } from './buildFormData';
 import { ContentType, HttpMethod } from './request.enum';
 import type { IMakeRequest } from './request.interface';
 import { errorTransformer, successTransformer } from './transformer';
@@ -15,7 +15,7 @@ export async function makeRequest<TResponse>({
   timeout,
 }: IMakeRequest) {
   // configure body
-  body = isFormData ? buildFormData(body as Record<string, any>) : body;
+  body = isFormData ? axios.toFormData(body as Record<string, any>) : body;
 
   // configure request header
   if (!isFormData) {
@@ -25,10 +25,14 @@ export async function makeRequest<TResponse>({
   }
 
   try {
-    const axios = axiosInstance(method);
+    const axios = axiosInstance({ baseURL, headers, timeout });
 
     //   send request
-    const resp = await axios(path, { baseURL, headers, timeout });
+    const resp = await axios({
+      url: path,
+      method,
+      data: body,
+    });
 
     // get response json
     const jsonResp: any = await resp.data;