@arquimedes.co/eureka-forms 3.0.34-test → 3.0.35

package/dist/Utils/FormStepFunctions.js

@@ -1,3 +1,12 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import AYFFormStepTypes from '../constants/AYFFormStepTypes';
 import CBRFormStepTypes from '../constants/CBRFormStepTypes';
 import ConditionTypes from '../constants/ConditionTypes';
@@ -5,36 +14,38 @@ import FormStepTypes, { ClassifierOptionTypes, EntityValueDataTypes, EntityValue
 export function calcRecursiveData(element, newSteps, customSteps) {
     if (!newSteps)
         return;
-    for (const [idStep, step] of Object.entries(newSteps)) {
+    for (var _i = 0, _a = Object.entries(newSteps); _i < _a.length; _i++) {
+        var _b = _a[_i], idStep = _b[0], step = _b[1];
         step.id = idStep;
         if (step.dependencies) {
-            for (let i = 0; i < step.dependencies.length; i++) {
-                const idDep = step.dependencies[i];
-                const newId = element.ids[idDep];
+            for (var i = 0; i < step.dependencies.length; i++) {
+                var idDep = step.dependencies[i];
+                var newId = element.ids[idDep];
                 if (newId) {
                     step.dependencies[i] = newId;
                 }
             }
         }
-        const custom = customSteps[step?.type];
-        if (custom?.calcRecursiveData) {
+        var custom = customSteps[step === null || step === void 0 ? void 0 : step.type];
+        if (custom === null || custom === void 0 ? void 0 : custom.calcRecursiveData) {
             custom.calcRecursiveData(step, element.ids);
         }
         if (step.condition) {
             calcRecursiveCondition(step.condition, element.ids);
         }
-        calcSubSteps(step.id, newSteps, (idStep) => element.ids[idStep] ?? idStep);
+        calcSubSteps(step.id, newSteps, function (idStep) { var _a; return (_a = element.ids[idStep]) !== null && _a !== void 0 ? _a : idStep; });
     }
 }
-export const calcRecursiveCondition = (condition, ids) => {
+export var calcRecursiveCondition = function (condition, ids) {
     switch (condition.type) {
         case ConditionTypes.EXPRESSION:
-            for (const subCondition of condition.conditions) {
+            for (var _i = 0, _a = condition.conditions; _i < _a.length; _i++) {
+                var subCondition = _a[_i];
                 calcRecursiveCondition(subCondition, ids);
             }
             break;
         case ConditionTypes.FORM_STEP: {
-            const newId = ids[condition.idStep];
+            var newId = ids[condition.idStep];
             if (newId) {
                 condition.idStep = newId;
             }
@@ -50,22 +61,24 @@ export const calcRecursiveCondition = (condition, ids) => {
  * @param idModifier optional modifier for the ids of the substeps and all other properties
  * @returns list of the ids of the substeps of the step, if modifier returns modified steps
  */
-export const calcSubSteps = (idStep, allSteps, idModifier) => {
-    const step = allSteps[idStep];
-    const subSteps = [];
+export var calcSubSteps = function (idStep, allSteps, idModifier) {
+    var _a;
+    var step = allSteps[idStep];
+    var subSteps = [];
     if (!step)
         return [];
-    const handleSteps = (steps) => {
-        for (let i = 0; i < steps.length; i++) {
-            const idSubStep = steps[i];
+    var handleSteps = function (steps) {
+        for (var i = 0; i < steps.length; i++) {
+            var idSubStep = steps[i];
             if (idModifier)
                 steps[i] = idModifier(steps[i]);
-            subSteps.push(idSubStep, ...calcSubSteps(idSubStep, allSteps, idModifier));
+            subSteps.push.apply(subSteps, __spreadArray([idSubStep], calcSubSteps(idSubStep, allSteps, idModifier), false));
         }
     };
     switch (step.type) {
         case FormStepTypes.SELECTOR: {
-            for (const option of step.options) {
+            for (var _i = 0, _b = step.options; _i < _b.length; _i++) {
+                var option = _b[_i];
                 if (option.type === OptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -73,8 +86,9 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         }
         case FormStepTypes.CLASSIFIER_SELECTOR:
-            for (const idOption of Object.keys(step.options)) {
-                const option = step.options[idOption];
+            for (var _c = 0, _d = Object.keys(step.options); _c < _d.length; _c++) {
+                var idOption = _d[_c];
+                var option = step.options[idOption];
                 if (option.type === ClassifierOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -82,7 +96,8 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         case FormStepTypes.RATING:
             if (step.nestedSteps) {
-                for (const steps of step.nestedSteps) {
+                for (var _e = 0, _f = step.nestedSteps; _e < _f.length; _e++) {
+                    var steps = _f[_e];
                     handleSteps(steps);
                 }
             }
@@ -100,19 +115,22 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
         }
         case FormStepTypes.ENTITYVALUEPICKER:
             if (idModifier) {
-                for (const path of step.path) {
+                for (var _g = 0, _h = step.path; _g < _h.length; _g++) {
+                    var path = _h[_g];
                     if (path.type === EntityValueDataTypes.STEP) {
                         path.idStep = idModifier(path.idStep);
                     }
                 }
-                for (const filter of step.filters) {
+                for (var _j = 0, _k = step.filters; _j < _k.length; _j++) {
+                    var filter = _k[_j];
                     if (filter.type === EntityValueDataTypes.STEP) {
                         filter.idStep = idModifier(filter.idStep);
                     }
                 }
             }
-            for (const idOption of Object.keys(step.options ?? {})) {
-                const option = step.options[idOption];
+            for (var _l = 0, _m = Object.keys((_a = step.options) !== null && _a !== void 0 ? _a : {}); _l < _m.length; _l++) {
+                var idOption = _m[_l];
+                var option = step.options[idOption];
                 if (option.type === EntityValueOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -120,7 +138,7 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         case CBRFormStepTypes.CBR_LOCATIVAS:
             {
-                const elementStep = step;
+                var elementStep = step;
                 if (elementStep.subStep) {
                     if (idModifier)
                         elementStep.subStep = idModifier(elementStep.subStep);
@@ -129,7 +147,7 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             }
             break;
         case AYFFormStepTypes.AYF_ICA_CITY: {
-            const cityStep = step;
+            var cityStep = step;
             if (cityStep.idNitStep) {
                 if (idModifier)
                     cityStep.idNitStep = idModifier(cityStep.idNitStep);

package/dist/Utils/MaterialProviders.d.ts

@@ -1,26 +1,6 @@
 import React from 'react';
-import { FormStyle } from '../@Types/Form';
-import { Palette, PaletteColor } from '@mui/material/styles';
-declare module '@mui/material/styles' {
-    interface Palette {
-        outline: Palette['primary'];
-        helperText: Palette['text'];
-        greyBtn: Palette['primary'];
-        stepBackgroundColor: Palette['background'];
-    }
-    interface PaletteOptions {
-        outline: PaletteOptions['primary'];
-        helperText: PaletteOptions['text'];
-        greyBtn: PaletteOptions['primary'];
-        stepBackgroundColor: PaletteOptions['background'];
-    }
-}
-export type PaletteKey = keyof {
-    [Key in keyof Palette as Palette[Key] extends PaletteColor ? Key : never]: true;
-};
 interface MaterialProvidersProps {
     children: React.ReactNode;
-    formStyle: FormStyle;
 }
-declare function MaterialProviders({ children, formStyle }: MaterialProvidersProps): JSX.Element;
+declare function MaterialProviders({ children }: MaterialProvidersProps): JSX.Element;
 export default MaterialProviders;

package/dist/Utils/MaterialProviders.js

@@ -1,49 +1,31 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import { jsx as _jsx } from "react/jsx-runtime";
-import { esES as DatePickersEs } from '@mui/x-date-pickers/locales';
-import { createTheme, ThemeProvider } from '@mui/material';
-import { AdapterDateFns } from '@mui/x-date-pickers/AdapterDateFns';
-import { LocalizationProvider } from '@mui/x-date-pickers';
-import { getLocale } from './LocaleUtils';
-import InternalFormStyle from '../constants/InternalFormStyle';
-function MaterialProviders({ children, formStyle = InternalFormStyle }) {
-    return (_jsx(ThemeProvider, { theme: createTheme({
-            typography: {
-                fontFamily: 'inherit',
-                button: {
-                    textTransform: 'none',
-                },
-            },
-            palette: {
-                primary: {
-                    main: formStyle.primaryColor,
-                    contrastText: formStyle.primaryContrastColor,
-                },
-                secondary: {
-                    main: formStyle.secondaryColor,
-                    contrastText: formStyle.secondaryContrastColor,
-                },
-                outline: {
-                    main: formStyle.outlineColor,
-                },
-                greyBtn: {
-                    main: '#d6d6d6',
-                    contrastText: '#293241',
-                },
-                helperText: {
-                    primary: formStyle.descriptionTextColor,
-                },
-                stepBackgroundColor: {
-                    default: formStyle.stepBackgroundColor,
-                },
-                error: {
-                    main: formStyle.errorColor,
-                },
-                text: {
-                    primary: formStyle.textColor,
-                    secondary: formStyle.descriptionTextColor,
-                },
-            },
-        }, DatePickersEs //Potencialmente cambiar esto dependiendo de la empresa?
-        ), children: _jsx(LocalizationProvider, { dateAdapter: AdapterDateFns, adapterLocale: getLocale(), children: children }) }));
+import { StylesProvider, ThemeProvider, createGenerateClassName, createTheme, } from '@material-ui/core';
+import DateFnsUtils from '@date-io/date-fns';
+import { MuiPickersUtilsProvider } from '@material-ui/pickers';
+import { SEED } from '../constants/MaterialClassNameSeed';
+import { getLocale } from '../Form/Form';
+var muiTheme = createTheme({
+    typography: {
+        fontFamily: 'inherit',
+    },
+});
+var generateClassName = createGenerateClassName({
+    seed: SEED,
+    productionPrefix: 'efjss',
+});
+function MaterialProviders(_a) {
+    var children = _a.children;
+    return (_jsx(StylesProvider, __assign({ generateClassName: generateClassName }, { children: _jsx(ThemeProvider, __assign({ theme: muiTheme }, { children: _jsx(MuiPickersUtilsProvider, __assign({ utils: DateFnsUtils, locale: getLocale() }, { children: children })) })) })));
 }
 export default MaterialProviders;

package/dist/Utils/PhoneFunctions.js

@@ -8,13 +8,13 @@ export function isValidPhoneNumber(phone) {
 export function isEmptyPhoneNumber(phone) {
     if (!phone.startsWith('+'))
         phone = '+' + phone;
-    const { country } = guessCountryByPartialPhoneNumber({
-        phone,
-    });
+    var country = guessCountryByPartialPhoneNumber({
+        phone: phone,
+    }).country;
     if (country &&
         !removeDialCode({
-            phone,
-            dialCode: country?.dialCode,
+            phone: phone,
+            dialCode: country === null || country === void 0 ? void 0 : country.dialCode,
         })) {
         return true;
     }

package/dist/Utils/StoreContext.js

@@ -1,2 +1,2 @@
 import React from 'react';
-export const StoreContext = React.createContext({});
+export var StoreContext = React.createContext({});

package/dist/Utils/TestUtils.d.ts

@@ -1,76 +1,97 @@
 import React from 'react';
-import type { RenderHookOptions, RenderHookResult, RenderOptions } from '@testing-library/react';
+import type { RenderOptions } from '@testing-library/react';
 import { AppStore } from './store';
+import { RenderHookOptions } from '@testing-library/react-hooks';
 interface ExtendedRenderOptions extends Omit<RenderOptions, 'queries'> {
     store?: AppStore;
 }
 export declare function renderWithProviders(ui: React.ReactElement, { store, ...renderOptions }?: ExtendedRenderOptions): {
     container: HTMLElement;
     baseElement: HTMLElement;
-    debug: (baseElement?: import("react-dom/client").Container | (Document | Element) | Array<import("react-dom/client").Container | (Document | Element)> | undefined, maxLength?: number | undefined, options?: import("pretty-format").OptionsReceived | undefined) => void;
-    rerender: (ui: React.ReactNode) => void;
+    debug: (baseElement?: Element | DocumentFragment | (Element | DocumentFragment)[] | undefined, maxLength?: number | undefined, options?: import("pretty-format").PrettyFormatOptions | undefined) => void;
+    rerender: (ui: React.ReactElement<any, string | React.JSXElementConstructor<any>>) => void;
     unmount: () => void;
     asFragment: () => DocumentFragment;
-    getByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement;
-    getAllByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement[];
-    queryByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement | null;
-    queryAllByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement[];
-    findByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByLabelText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement;
-    getAllByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    queryByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement | null;
-    queryAllByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    findByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByPlaceholderText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement;
-    getAllByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement[];
-    queryByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement | null;
-    queryAllByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined) => HTMLElement[];
-    findByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement;
-    getAllByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    queryByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement | null;
-    queryAllByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    findByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByAltText: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement;
-    getAllByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    queryByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement | null;
-    queryAllByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    findByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByTitle: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement;
-    getAllByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    queryByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement | null;
-    queryAllByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    findByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByDisplayValue: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined) => HTMLElement;
-    getAllByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined) => HTMLElement[];
-    queryByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined) => HTMLElement | null;
-    queryAllByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined) => HTMLElement[];
-    findByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByRole: (role: import("@testing-library/dom").ByRoleMatcher, options?: import("@testing-library/dom").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    getByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement;
-    getAllByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    queryByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement | null;
-    queryAllByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined) => HTMLElement[];
-    findByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement>;
-    findAllByTestId: (id: import("@testing-library/dom").Matcher, options?: import("@testing-library/dom").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/dom").waitForOptions | undefined) => Promise<HTMLElement[]>;
-    store: import("@reduxjs/toolkit").EnhancedStore<{
-        forms: import("./store").EurekaFormsState;
+    getByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement;
+    getAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    queryByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement | null;
+    queryAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    findByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    store: import("@reduxjs/toolkit/dist/configureStore").ToolkitStore<import("redux").EmptyObject & {
+        forms: {
+            [x: string]: import("./store").RootState;
+        };
         api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
-    }, import("redux").UnknownAction | import("redux").AnyAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
-        dispatch: import("redux-thunk").ThunkDispatch<{
-            forms: import("./store").EurekaFormsState;
-            api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
-        }, undefined, import("redux").UnknownAction>;
-    }>, import("redux").StoreEnhancer]>>;
+    }, import("redux").AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
+        forms: {
+            [x: string]: import("./store").RootState;
+        };
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
+    }>, import("redux").AnyAction, undefined>, import("redux").Middleware<{}, import("@reduxjs/toolkit/query").RootState<{}, string, "api">, import("@reduxjs/toolkit").ThunkDispatch<any, any, import("redux").AnyAction>>]>>;
 };
 interface ExtendedRenderHookOptions<TProps> extends Omit<RenderHookOptions<TProps>, 'wrapper'> {
     store?: AppStore;
 }
-export declare function renderHookWithProviders<TProps, TResult>(callback: (props: TProps) => TResult, { store, ...renderHookOptions }?: ExtendedRenderHookOptions<TProps>): RenderHookResult<TResult, TProps>;
+export declare function renderHookWithProviders<TProps, TResult>(callback: (props: TProps) => TResult, { store, ...renderHookOptions }?: ExtendedRenderHookOptions<TProps>): {
+    result: import("@testing-library/react-hooks").RenderResult<TResult>;
+    rerender: (props?: TProps | undefined) => void;
+    unmount: () => void;
+    waitFor: import("@testing-library/react-hooks").WaitFor;
+    waitForValueToChange: import("@testing-library/react-hooks").WaitForValueToChange;
+    waitForNextUpdate: import("@testing-library/react-hooks").WaitForNextUpdate;
+    store: import("@reduxjs/toolkit/dist/configureStore").ToolkitStore<import("redux").EmptyObject & {
+        forms: {
+            [x: string]: import("./store").RootState;
+        };
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
+    }, import("redux").AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
+        forms: {
+            [x: string]: import("./store").RootState;
+        };
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
+    }>, import("redux").AnyAction, undefined>, import("redux").Middleware<{}, import("@reduxjs/toolkit/query").RootState<{}, string, "api">, import("@reduxjs/toolkit").ThunkDispatch<any, any, import("redux").AnyAction>>]>>;
+};
 export {};

package/dist/Utils/TestUtils.js

@@ -1,43 +1,72 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { render, renderHook } from '@testing-library/react';
+import { render } from '@testing-library/react';
 import { combineReducers, configureStore, nanoid } from '@reduxjs/toolkit';
 import { Provider } from 'react-redux';
 // As a basic setup, import your same slice reducers
 import { EurekaFormsReducer } from './store';
-import { IdFormContext } from '../Contexts/FormContext';
+import { renderHook } from '@testing-library/react-hooks';
+import { IdFormContext } from '../App/App';
 import { RootApi } from './_api';
 import { StoreContext } from './StoreContext';
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function renderWithProviders(ui, { 
-// Automatically create a store instance if no store was passed in
-store = configureStore({
-    reducer: combineReducers({
-        forms: EurekaFormsReducer,
-        api: RootApi.reducer,
-    }),
-}), ...renderOptions } = {}) {
-    function Wrapper({ children }) {
-        return _jsx(Provider, { store: store, children: children });
+export function renderWithProviders(ui, _a) {
+    if (_a === void 0) { _a = {}; }
+    var 
+    // Automatically create a store instance if no store was passed in
+    _b = _a.store, 
+    // Automatically create a store instance if no store was passed in
+    store = _b === void 0 ? configureStore({
+        reducer: combineReducers({
+            forms: EurekaFormsReducer,
+            api: RootApi.reducer,
+        }),
+    }) : _b, renderOptions = __rest(_a, ["store"]);
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function Wrapper(_a) {
+        var children = _a.children;
+        return _jsx(Provider, __assign({ store: store }, { children: children }));
     }
     // Return an object with the store and all of RTL's query functions
-    return { store, ...render(ui, { wrapper: Wrapper, ...renderOptions }) };
+    return __assign({ store: store }, render(ui, __assign({ wrapper: Wrapper }, renderOptions)));
 }
-export function renderHookWithProviders(callback, { store = configureStore({
-    reducer: combineReducers({
-        forms: EurekaFormsReducer,
-        api: RootApi.reducer,
-    }),
-}), ...renderHookOptions } = {}) {
-    function Wrapper({ children }) {
-        const [idForm] = React.useState(nanoid(6));
-        return (_jsx(IdFormContext.Provider, { value: idForm, children: _jsx(Provider, { store: store, context: StoreContext, children: children }) }));
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function renderHookWithProviders(callback, _a) {
+    if (_a === void 0) { _a = {}; }
+    var _b = _a.store, store = _b === void 0 ? configureStore({
+        reducer: combineReducers({
+            forms: EurekaFormsReducer,
+            api: RootApi.reducer,
+        }),
+    }) : _b, renderHookOptions = __rest(_a, ["store"]);
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function Wrapper(_a) {
+        var children = _a.children;
+        var idForm = React.useState(nanoid(6))[0];
+        return (_jsx(IdFormContext.Provider, __assign({ value: idForm }, { children: _jsx(Provider, __assign({ store: store, context: StoreContext }, { children: children })) })));
     }
     // Return an object with the store and all of RTL's query functions
-    return {
-        ...renderHook(callback, {
-            wrapper: Wrapper,
-            ...renderHookOptions,
-        }),
-    };
+    return __assign({ store: store }, renderHook(callback, __assign({ wrapper: Wrapper }, renderHookOptions)));
 }

package/dist/Utils/_api.d.ts

@@ -1,8 +1,8 @@
-export declare const RootApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<{
+export declare const RootApi: import("@reduxjs/toolkit/query/react").Api<import("@reduxjs/toolkit/query/react").BaseQueryFn<{
     url: string;
-    timeout?: import("axios").AxiosRequestConfig["timeout"];
-    method?: import("axios").AxiosRequestConfig["method"];
-    body?: import("axios").AxiosRequestConfig["data"];
-    params?: import("axios").AxiosRequestConfig["params"];
-    headers?: Record<string, any>;
-}, unknown, unknown>, {}, "api", never, typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    timeout?: number | undefined;
+    method?: string | undefined;
+    body?: any;
+    params?: any;
+    headers?: Record<string, any> | undefined;
+}, unknown, unknown, {}, {}>, {}, "api", never, typeof import("@reduxjs/toolkit/query/react").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/Utils/_api.js

@@ -1,15 +1,13 @@
-import { buildCreateApi, coreModule, reactHooksModule } from '@reduxjs/toolkit/query/react';
+import { buildCreateApi, coreModule, reactHooksModule, } from '@reduxjs/toolkit/query/react';
 import { axiosBaseQuery } from './AxiosAPI';
-import { createDispatchHook, createSelectorHook, createStoreHook } from 'react-redux';
+import { createDispatchHook, createSelectorHook, createStoreHook, } from 'react-redux';
 import { StoreContext } from './StoreContext';
-const customCreateApi = buildCreateApi(coreModule(), reactHooksModule({
-    hooks: {
-        useDispatch: createDispatchHook(StoreContext),
-        useSelector: createSelectorHook(StoreContext),
-        useStore: createStoreHook(StoreContext),
-    },
+var customCreateApi = buildCreateApi(coreModule(), reactHooksModule({
+    useDispatch: createDispatchHook(StoreContext),
+    useSelector: createSelectorHook(StoreContext),
+    useStore: createStoreHook(StoreContext),
 }));
-export const RootApi = customCreateApi({
+export var RootApi = customCreateApi({
     baseQuery: axiosBaseQuery(),
-    endpoints: () => ({}),
+    endpoints: function () { return ({}); },
 });