@arquimedes.co/eureka-forms 3.0.41 → 3.0.42-test

package/dist/Utils/LocaleUtils.js

@@ -0,0 +1,12 @@
+import { enUS } from 'date-fns/locale/en-US';
+import { es } from 'date-fns/locale/es';
+const localeMap = {
+    en: enUS,
+    'en-US': enUS,
+    es,
+};
+export const getLocale = () => {
+    return (localeMap[navigator.languages?.length
+        ? navigator.languages[0]
+        : (navigator.userLanguage ?? navigator.language ?? navigator.browserLanguage)] ?? localeMap.es);
+};

package/dist/Utils/MaterialProviders.d.ts

@@ -1,6 +1,26 @@
 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 }: MaterialProvidersProps): JSX.Element;
+declare function MaterialProviders({ children, formStyle }: MaterialProvidersProps): JSX.Element;
 export default MaterialProviders;

package/dist/Utils/MaterialProviders.js

@@ -1,31 +1,49 @@
-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 { 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 })) })) })));
+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 }) }));
 }
 export default MaterialProviders;

package/dist/Utils/MuiClassnameSetup.d.ts

@@ -0,0 +1 @@
+export declare const SEED = "Erk";

package/dist/Utils/MuiClassnameSetup.js

@@ -0,0 +1,3 @@
+import { unstable_ClassNameGenerator as ClassNameGenerator } from '@mui/material/className';
+export const SEED = 'Erk';
+ClassNameGenerator.configure((componentName) => `${SEED}-${componentName}`);

package/dist/Utils/PhoneFunctions.js

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

package/dist/Utils/StoreContext.js

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

package/dist/Utils/TestUtils.d.ts

@@ -1,97 +1,76 @@
 import React from 'react';
-import type { RenderOptions } from '@testing-library/react';
+import type { RenderHookOptions, RenderHookResult, 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?: 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;
+    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;
     unmount: () => void;
     asFragment: () => DocumentFragment;
-    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;
-        };
+    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;
         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>>]>>;
+    }, 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]>>;
 };
 interface ExtendedRenderHookOptions<TProps> extends Omit<RenderHookOptions<TProps>, 'wrapper'> {
     store?: AppStore;
 }
-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 declare function renderHookWithProviders<TProps, TResult>(callback: (props: TProps) => TResult, { store, ...renderHookOptions }?: ExtendedRenderHookOptions<TProps>): RenderHookResult<TResult, TProps>;
 export {};

package/dist/Utils/TestUtils.js

@@ -1,72 +1,43 @@
-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 } from '@testing-library/react';
+import { render, renderHook } 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 { renderHook } from '@testing-library/react-hooks';
-import { IdFormContext } from '../App/App';
+import { IdFormContext } from '../Contexts/FormContext';
 import { RootApi } from './_api';
 import { StoreContext } from './StoreContext';
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-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 }));
+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 });
     }
     // Return an object with the store and all of RTL's query functions
-    return __assign({ store: store }, render(ui, __assign({ wrapper: Wrapper }, renderOptions)));
+    return { store, ...render(ui, { wrapper: Wrapper, ...renderOptions }) };
 }
-// 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 })) })));
+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 }) }));
     }
     // Return an object with the store and all of RTL's query functions
-    return __assign({ store: store }, renderHook(callback, __assign({ wrapper: Wrapper }, renderHookOptions)));
+    return {
+        ...renderHook(callback, {
+            wrapper: Wrapper,
+            ...renderHookOptions,
+        }),
+    };
 }

package/dist/Utils/_api.d.ts

@@ -1,8 +1,8 @@
-export declare const RootApi: import("@reduxjs/toolkit/query/react").Api<import("@reduxjs/toolkit/query/react").BaseQueryFn<{
+export declare const RootApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<{
     url: string;
-    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>;
+    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>;

package/dist/Utils/_api.js

@@ -1,13 +1,15 @@
-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';
-var customCreateApi = buildCreateApi(coreModule(), reactHooksModule({
-    useDispatch: createDispatchHook(StoreContext),
-    useSelector: createSelectorHook(StoreContext),
-    useStore: createStoreHook(StoreContext),
+const customCreateApi = buildCreateApi(coreModule(), reactHooksModule({
+    hooks: {
+        useDispatch: createDispatchHook(StoreContext),
+        useSelector: createSelectorHook(StoreContext),
+        useStore: createStoreHook(StoreContext),
+    },
 }));
-export var RootApi = customCreateApi({
+export const RootApi = customCreateApi({
     baseQuery: axiosBaseQuery(),
-    endpoints: function () { return ({}); },
+    endpoints: () => ({}),
 });

package/dist/Utils/store.d.ts

@@ -7,29 +7,21 @@ export interface RootState {
     site: SiteState;
     widthStats: WidthStats;
 }
+export type EurekaFormsState = Record<string, RootState>;
 export declare const defaultRootState: RootState;
-type EurekaFormsState = Record<string, RootState>;
 export declare function EurekaFormsReducer(state: EurekaFormsState | undefined, action: AnyAction): EurekaFormsState;
-export declare const store: import("@reduxjs/toolkit/dist/configureStore").ToolkitStore<import("redux").EmptyObject & {
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
     forms: EurekaFormsState;
     api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
-}, AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
-    forms: EurekaFormsState;
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
-}>, AnyAction, undefined>, import("redux").Middleware<{}, import("@reduxjs/toolkit/query").RootState<{}, string, "api">, import("@reduxjs/toolkit").ThunkDispatch<any, any, AnyAction>>]>>;
+}, import("redux").UnknownAction | AnyAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        forms: EurekaFormsState;
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, never, "api">;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
 export type AppDispatch = typeof store.dispatch;
 export type AppStore = typeof store;
 export type AppState = ReturnType<typeof store.getState>;
 export declare const getAppState: import("@reduxjs/toolkit").AsyncThunk<RootState, {
     idForm: string;
-}, {
-    state?: unknown;
-    dispatch?: import("redux").Dispatch<AnyAction> | undefined;
-    extra?: unknown;
-    rejectValue?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-}>;
-export {};
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;