@ventlio/tanstack-query 0.2.6 → 0.2.7-2.1

package/dist/queries/usePatchRequest.js

@@ -1,44 +1,52 @@
-'use strict';
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import 'url-search-params-polyfill';
+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';
 
-var reactQuery = require('@tanstack/react-query');
-var scrollToTop = require('../helpers/scrollToTop.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-var request_enum = require('../request/request.enum.js');
-var useQueryConfig = require('../config/useQueryConfig.js');
-
-const usePatchRequest = ({ path, }) => {
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
-    // register post mutation
-    const mutation = reactQuery.useMutation((postData) => new Promise((res, rej) => {
-        makeRequest.makeRequest({
+const usePatchRequest = ({ path, baseUrl, headers }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { getHeaders } = useQueryHeaders();
+    const queryClient = useQueryClient();
+    const config = queryClient.getQueryData(['config']);
+    const sendRequest = async (res, rej, data) => {
+        // get request headers
+        const globalHeaders = getHeaders();
+        const patchResponse = await makeRequest({
             path: path,
-            body: postData,
-            method: request_enum.HttpMethod.PATCH,
-            headers,
-            baseURL,
-            timeout,
-        }).then((postResponse) => {
-            if (postResponse.status) {
-                // scroll to top after success
-                scrollToTop.scrollToTop();
-                res(postResponse);
+            body: data,
+            method: HttpMethod.PATCH,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+        });
+        if (patchResponse.status) {
+            // scroll to top after success
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
             }
-            else {
-                // scroll to top after error
-                window.scrollTo({
-                    top: 0,
-                    behavior: 'smooth',
-                });
-                rej(postResponse);
+            res(patchResponse);
+        }
+        else {
+            // scroll to top after error
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
             }
-        });
+            rej(patchResponse);
+        }
+    };
+    // register post mutation
+    const mutation = useMutation((dataData) => new Promise((res, rej) => {
+        return sendRequest(res, rej, dataData);
     }));
-    const patch = async (postData, options) => {
-        return mutation.mutateAsync(postData, options);
+    const patch = async (data, options) => {
+        return mutation.mutateAsync(data, options);
     };
     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.d.ts

@@ -1,9 +1,11 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
-export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, headers, fileSelectors, }: {
     path: string;
     isFormData?: boolean | undefined;
-}) => {
+    fileSelectors?: string[] | undefined;
+} & DefaultRequestOptions) => {
     data: undefined;
     error: null;
     isError: false;
@@ -19,7 +21,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    post: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: undefined;
     error: null;
@@ -36,7 +38,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    post: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: undefined;
     error: IRequestError;
@@ -53,7 +55,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    post: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
     data: IRequestSuccess<TResponse>;
     error: null;
@@ -70,5 +72,5 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     isPaused: boolean;
     variables: void | undefined;
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
+    post: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 };

package/dist/queries/usePostRequest.js

@@ -1,47 +1,57 @@
-'use strict';
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import 'url-search-params-polyfill';
+import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useReactNativeEnv } from '../config/useReactNativeEnv.js';
+import { scrollToTop } from '../helpers/scrollToTop.js';
+import 'axios';
+import { makeRequest } from '../request/make-request.js';
+import { HttpMethod } from '../request/request.enum.js';
 
-var reactQuery = require('@tanstack/react-query');
-var useQueryConfig = require('../config/useQueryConfig.js');
-require('axios');
-var makeRequest = require('../request/make-request.js');
-var request_enum = require('../request/request.enum.js');
-
-const usePostRequest = ({ path, isFormData = false, }) => {
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
-    // register post mutation
-    const mutation = reactQuery.useMutation(async (postData) => new Promise((res, rej) => {
-        makeRequest.makeRequest({
-            path: path,
+const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const queryClient = useQueryClient();
+    const { getHeaders } = useQueryHeaders();
+    const { isApp } = useReactNativeEnv();
+    const sendRequest = async (res, rej, postData) => {
+        // get request headers
+        const globalHeaders = getHeaders();
+        const config = queryClient.getQueryData(['config']);
+        const postResponse = await makeRequest({
+            path,
             body: postData,
-            method: request_enum.HttpMethod.POST,
+            method: HttpMethod.POST,
             isFormData,
-            headers,
-            baseURL,
-            timeout,
-        }).then((postResponse) => {
-            if (postResponse.status) {
-                // scroll to top after success
-                window.scrollTo({
-                    top: 0,
-                    behavior: 'smooth',
-                });
-                res(postResponse);
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+            appFileConfig: {
+                isApp,
+                fileSelectors,
+            },
+        });
+        if (postResponse.status) {
+            // scroll to top after success
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
             }
-            else {
-                // scroll to top after error
-                window.scrollTo({
-                    top: 0,
-                    behavior: 'smooth',
-                });
-                rej(postResponse);
+            res(postResponse);
+        }
+        else {
+            // scroll to top after error
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
             }
-        });
-    }));
-    const post = async (postData, options) => {
-        return mutation.mutateAsync(postData, options);
+            rej(postResponse);
+        }
+    };
+    // register post mutation
+    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,3 +1,3 @@
 import type { AxiosInstance } from 'axios';
 import type { IMakeRequest } from './request.interface';
-export declare const axiosInstance: ({ baseURL, timeout, headers, }: Partial<IMakeRequest>) => AxiosInstance;
+export declare const axiosInstance: ({ baseURL, timeout, headers }: Partial<IMakeRequest>) => AxiosInstance;

package/dist/request/axios-instance.js

@@ -1,8 +1,6 @@
-'use strict';
+import axios from 'axios';
 
-var axios = require('axios');
-
-const axiosInstance = ({ baseURL, timeout, headers, }) => {
+const axiosInstance = ({ baseURL, timeout, headers }) => {
     return axios.create({
         baseURL,
         timeout,
@@ -10,5 +8,5 @@ const axiosInstance = ({ baseURL, timeout, headers, }) => {
     });
 };
 
-exports.axiosInstance = axiosInstance;
+export { axiosInstance };
 //# sourceMappingURL=axios-instance.js.map

package/dist/request/axios-instance.js.map

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

package/dist/request/buildFormData.d.ts

@@ -1 +1 @@
-export declare const buildFormData: (body: Record<string, any>) => Record<string, any>;
+export declare const buildFormData: (body: Record<string, any>) => FormData;

package/dist/request/buildFormData.js

@@ -1,14 +1,44 @@
-'use strict';
-
 const buildFormData = (body) => {
     const formData = new FormData();
+    const handleArrayValue = (key, value) => {
+        for (const item of value) {
+            if (item instanceof File) {
+                formData.append(key, item);
+            }
+            else if (item instanceof Object) {
+                formData.append(key, JSON.stringify(item));
+            }
+            else {
+                formData.append(key, item);
+            }
+        }
+    };
+    const handleObjectValue = (key, value) => {
+        if (value instanceof File) {
+            formData.append(key, value);
+        }
+        else {
+            formData.append(key, JSON.stringify(value));
+        }
+    };
+    const handlePrimitiveValue = (key, value) => {
+        formData.append(key, value);
+    };
     const bodyKeys = Object.keys(body);
     bodyKeys.forEach((key) => {
-        formData.append(key, body[key]);
+        const inputValue = body[key];
+        if (Array.isArray(inputValue) && inputValue.length > 0) {
+            handleArrayValue(key, inputValue);
+        }
+        else if (inputValue instanceof Object) {
+            handleObjectValue(key, inputValue);
+        }
+        else {
+            handlePrimitiveValue(key, inputValue);
+        }
     });
-    body = formData;
-    return 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.d.ts

@@ -1,2 +1,2 @@
 import type { IMakeRequest } from './request.interface';
-export declare function makeRequest<TResponse>({ body, method, path, isFormData, headers, baseURL, timeout, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;
+export declare function makeRequest<TResponse>({ body, method, path, isFormData, headers, baseURL, timeout, appFileConfig, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;

package/dist/request/make-request.js

@@ -1,21 +1,43 @@
-'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, appFileConfig, }) {
+    // check if file is included in mobile app environment and extract all file input to avoid
+    // it being formatted to object using axios formData builder
+    const isApp = appFileConfig?.isApp;
+    const appFiles = isApp ? getAppFiles(body, appFileConfig.fileSelectors) : {};
     // configure body
-    body = isFormData ? buildFormData.buildFormData(body) : body;
-    // configure request header
+    body = (isFormData ? axios.toFormData(body) : body);
+    // configure request header1
     if (!isFormData) {
-        headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
+        headers['Content-Type'] = ContentType.APPLICATION_JSON;
+    }
+    else {
+        if (isApp) {
+            headers['Content-Type'] = ContentType.MULTIPART_FORM_DATA;
+            // add the app files
+            for (const fileKey in appFiles) {
+                const currentFile = appFiles[fileKey];
+                if (Array.isArray(currentFile)) {
+                    for (const innerFile of currentFile) {
+                        body.append(fileKey, innerFile);
+                    }
+                }
+                else {
+                    body.append(fileKey, currentFile);
+                }
+            }
+        }
+        else {
+            delete headers['Content-Type'];
+        }
     }
     try {
-        const axios = axiosInstance.axiosInstance({ baseURL, headers, timeout });
+        const axiosRequest = axiosInstance({ baseURL, headers, timeout });
         //   send request
-        const resp = await axios({
+        const resp = await axiosRequest({
             url: path,
             method,
             data: body,
@@ -26,21 +48,37 @@ async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, i
         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({
-            data: jsonResp,
+        return successTransformer({
             statusCode: responseCode,
+            ...jsonResp,
+            status: resp.status,
         });
     }
     catch (error) {
-        return transformer.errorTransformer({
+        const errorData = error?.response?.data;
+        return errorTransformer({
             statusCode: error.status,
             message: error.message,
             code: error.status || error.statusCode,
+            ...errorData,
         });
     }
+}
+function getAppFiles(body, fileSelectors = []) {
+    const files = {};
+    if (body) {
+        if (fileSelectors.length > 0) {
+            //
+            for (const fileKey of fileSelectors) {
+                files[fileKey] = body[fileKey];
+                delete body[fileKey];
+            }
+        }
+    }
+    return files;
 }
 
-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/request.interface.d.ts

@@ -8,6 +8,11 @@ export interface IMakeRequest {
     method?: HttpMethod;
     isFormData?: boolean;
     headers: RawAxiosRequestHeaders;
+    appFileConfig?: AppFileConfig;
+}
+export interface AppFileConfig {
+    fileSelectors?: string[];
+    isApp: boolean;
 }
 export interface AxiosInstanceOption {
     bearerToken?: string;

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/dist/types/index.d.ts

@@ -1,18 +1,21 @@
 import type { RawAxiosRequestHeaders } from 'axios';
+export interface BootstrapConfig {
+    environments?: {
+        appBaseUrl: string;
+        appTimeout: number;
+    };
+    context?: ContextType;
+    modelConfig?: BootstrapModelConfig;
+}
+export interface BootstrapModelConfig {
+    idColumn: string;
+}
+export type ContextType = 'app' | 'web' | 'electronjs';
 export interface TanstackQueryConfig {
-    baseURL: string;
-    timeout?: number;
     headers: RawAxiosRequestHeaders;
+    options?: BootstrapConfig;
 }
 export interface IUseQueryHeaders {
-    headers: TanstackQueryConfig['headers'];
+    getHeaders: () => TanstackQueryConfig['headers'];
     setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
 }
-export interface IUseQueryTimeout {
-    timeout: TanstackQueryConfig['timeout'];
-    setQueryTimeout: (timeout: TanstackQueryConfig['timeout']) => void;
-}
-export interface IUseQueryBaseURL {
-    baseURL: TanstackQueryConfig['baseURL'];
-    setQueryBaseUrl: (baseURL: TanstackQueryConfig['baseURL']) => void;
-}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.6",
+  "version": "0.2.72.1",
   "license": "MIT",
   "main": "dist/index.js",
+  "contributors": [
+    {
+      "email": "soromgawide@gmail.com",
+      "name": "stancobridge",
+      "url": "https://github.com/stancobridge"
+    }
+  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/ventlio-tech/tanstact-query.git"
+    "url": "https://github.com/ventlio-tech/tanstack-query.git"
   },
   "types": "dist/index.d.ts",
   "author": {
@@ -15,12 +22,14 @@
   },
   "scripts": {
     "build": "rimraf dist && rollup --config rollup.config.ts --configPlugin rollup-plugin-typescript2",
-    "build:watch": "yarn build -w"
+    "build:watch": "yarn build -w",
+    "test": "jest"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^4.26.1",
     "axios": "^1.3.4",
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0",
     "react-native": "*"
   },
   "peerDependenciesMeta": {
@@ -39,12 +48,18 @@
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-typescript": "^11.0.0",
     "@tanstack/react-query": "^4.26.1",
+    "@testing-library/react-hooks": "^8.0.1",
     "@types/axios": "^0.14.0",
+    "@types/jest": "^29.5.1",
+    "@types/lodash.result": "^4.5.7",
+    "@types/lodash.set": "^4.3.7",
     "@types/node": "*",
-    "@types/react": "^18.0.28",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
     "@typescript-eslint/eslint-plugin": "^5.54.1",
     "@typescript-eslint/parser": "^5.54.1",
     "axios": "^1.3.4",
+    "axios-mock-adapter": "^1.21.4",
     "eslint": "^8.36.0",
     "eslint-config-google": "^0.14.0",
     "eslint-config-prettier": "^8.7.0",
@@ -53,11 +68,15 @@
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-react": "^7.32.2",
     "eslint-plugin-react-hooks": "^4.6.0",
+    "jest": "^29.5.0",
+    "jest-environment-jsdom": "^29.5.0",
     "prettier": "^2.8.4",
     "react": "^18.2.0",
+    "react-dom": "^18.2.0",
     "rimraf": "^4.4.0",
     "rollup": "^3.19.1",
     "rollup-plugin-typescript2": "^0.34.1",
+    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
     "typescript": "^4.9.5"
@@ -65,5 +84,10 @@
   "files": [
     "dist/**/*",
     "src"
-  ]
+  ],
+  "dependencies": {
+    "lodash.result": "^4.5.2",
+    "lodash.set": "^4.3.2",
+    "url-search-params-polyfill": "^8.2.5"
+  }
 }