@arquimedes.co/eureka-forms 2.0.32 → 2.0.34-test

package/dist/mjs/Shared/RoundedTextField/RoundedTextField.stories.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useArgs } from '@storybook/preview-api';
+import RoundedTextField from './RoundedTextField';
+import { within, userEvent } from '@storybook/testing-library';
+const meta = {
+    component: RoundedTextField,
+    tags: ['autodocs'],
+    args: {
+        focusColor: '#3d5a7f',
+        helperTextColor: '#989898',
+        outlineColor: '#0000003b',
+        backgroundColor: 'white',
+        textColor: '#293241',
+        readOnly: false,
+        borderRadius: 10,
+        padding: '6px 12px',
+        fontSize: '1rem',
+        errorColor: '#cc2936',
+        fontWeight: '300',
+        multiline: false,
+        cantEdit: false,
+    },
+};
+export default meta;
+export const Empty = {
+    args: {},
+};
+export const EmptyLabel = {
+    args: {
+        label: 'Label',
+    },
+};
+export const Default = {
+    args: {
+        label: 'Label',
+    },
+    play: async ({ canvasElement }) => {
+        const canvas = within(canvasElement);
+        const emailInput = canvas.getByRole('textbox');
+        await userEvent.click(emailInput);
+        await userEvent.type(emailInput, 'example-email@email.com', {
+            delay: 100,
+        });
+    },
+    render: function Component(args) {
+        const [, setArgs] = useArgs();
+        const onValueChange = (event) => {
+            const value = event.target.value;
+            args.onChange?.(event);
+            setArgs({ value });
+        };
+        return (_jsx(RoundedTextField, { ...args, ref: undefined, onChange: onValueChange }));
+    },
+};
+export const Focused = {
+    args: {
+        label: 'Label',
+    },
+    play: async ({ canvasElement }) => {
+        const canvas = within(canvasElement);
+        const emailInput = canvas.getByRole('textbox');
+        await userEvent.click(emailInput);
+    },
+};
+export const FocusedNoLabel = {
+    args: {},
+    play: async ({ canvasElement }) => {
+        const canvas = within(canvasElement);
+        const emailInput = canvas.getByRole('textbox');
+        await userEvent.click(emailInput);
+    },
+};
+export const WithValue = {
+    args: {
+        value: 'Textinput Value',
+    },
+};
+export const Multiline = {
+    args: {
+        value: 'TextArea Value',
+        multiline: true,
+        minRows: 4,
+    },
+};
+export const WithHelperText = {
+    args: {
+        helperText: 'Helper text',
+    },
+};
+export const WithValueandLabel = {
+    args: {
+        label: 'Label',
+        value: 'Textinput Value',
+    },
+};
+export const WithMaxLength = {
+    args: {
+        value: 'Value',
+        maxLength: 10,
+    },
+};
+export const Full = {
+    args: {
+        label: 'Label',
+        value: 'Value',
+        helperText: 'Helper text',
+        maxLength: 10,
+    },
+};
+export const Error = {
+    args: {
+        label: 'Label',
+        value: 'Value',
+        helperText: 'Helper text',
+        error: true,
+    },
+};
+export const ErrorColor = {
+    args: {
+        label: 'Label',
+        value: 'Value',
+        helperText: 'Helper text',
+        error: true,
+        errorColor: 'blue',
+    },
+};
+export const DifferentColors = {
+    args: {
+        label: 'Label',
+        value: 'Value',
+        helperText: 'Helper text',
+        maxLength: 10,
+        helperTextColor: 'green',
+        outlineColor: 'purple',
+        backgroundColor: 'red',
+        textColor: 'blue',
+    },
+};

package/dist/mjs/States/GlobalSlice.d.ts

@@ -0,0 +1,34 @@
+import { FormStyle } from '../@Types/Form';
+import type { PayloadAction } from '@reduxjs/toolkit';
+import { SiteState } from './SiteSlice';
+export interface GlobalState {
+    idOrganization: string;
+    formStyle: FormStyle;
+    /** If the formsteps can be edited (For internal) */
+    editable: boolean;
+    preview: boolean;
+    postview: boolean;
+    partial: boolean;
+    internal: boolean;
+    loaded: boolean;
+}
+export declare const GlobalSlice: import("@reduxjs/toolkit").Slice<GlobalState, {
+    reset: (state: import("immer/dist/internal").WritableDraft<GlobalState>, action: PayloadAction<Omit<GlobalState, 'loaded'> & SiteState>) => {
+        loaded: true;
+        editable: boolean;
+        partial: boolean;
+        postview: boolean;
+        formStyle: FormStyle;
+        preview: boolean;
+        idOrganization: string;
+        internal: boolean;
+        dependencies: import("../Form/Form").DependencyStore;
+        values: import("./SiteSlice").ValuesStore;
+        idCurrentSection: string | null;
+        previousSections: string[];
+        nextSections: string[];
+        focusStep?: string | undefined;
+    };
+}, "global">;
+export declare const reset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Omit<GlobalState, "loaded"> & SiteState, "global/reset">;
+export default GlobalSlice;

package/dist/mjs/States/GlobalSlice.js

@@ -0,0 +1,23 @@
+import InternalFormStyle from '../constants/InternalFormStyle';
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {
+    idOrganization: '',
+    formStyle: InternalFormStyle,
+    editable: false,
+    preview: false,
+    postview: false,
+    partial: false,
+    internal: false,
+    loaded: false,
+};
+export const GlobalSlice = createSlice({
+    name: 'global',
+    initialState,
+    reducers: {
+        reset: (state, action) => {
+            return { ...state, ...action.payload, loaded: true };
+        },
+    },
+});
+export const { reset } = GlobalSlice.actions;
+export default GlobalSlice;

package/dist/mjs/States/SiteSlice.d.ts

@@ -0,0 +1,65 @@
+import { DependencyStore, StepDependency } from '../Form/Form';
+import { GBaseStep } from '../@Types/GenericFormSteps';
+import { FormStep } from '../@Types/FormStep';
+import { CustomStep } from '../FormSteps/CustomStep';
+import { CBRFormStep } from '../@Types/CBRFormStep';
+import type { PayloadAction } from '@reduxjs/toolkit';
+import { FieldValues } from 'react-hook-form';
+export interface SiteState {
+    dependencies: DependencyStore;
+    values: ValuesStore;
+    idCurrentSection: string | null;
+    previousSections: string[];
+    nextSections: string[];
+    focusStep?: string;
+}
+export interface ValuesStore {
+    global: Record<string, any>;
+    sections: Record<string, Record<string, any>>;
+}
+export declare const SiteSlice: import("@reduxjs/toolkit").Slice<SiteState, {
+    setStepDependency: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload: { step: { id, type, idSection }, value, }, }: {
+        payload: {
+            step: GBaseStep;
+            value: StepDependency['value'];
+        };
+        type: string;
+    }) => void;
+    clearDependency: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload: { id, idSection } }: PayloadAction<GBaseStep>) => void;
+    setEmptyDependency: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload: { step: { id }, empty, }, }: {
+        payload: {
+            step: GBaseStep;
+            empty: StepDependency['empty'];
+        };
+        type: string;
+    }) => void;
+    addStepsDependencies: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload: { steps, customSteps, allSteps }, }: {
+        payload: {
+            steps: Record<string, FormStep | CBRFormStep>;
+            customSteps: Record<string, CustomStep>;
+            allSteps: Record<string, FormStep | CBRFormStep>;
+        };
+        type: string;
+    }) => void;
+    handlePrevious: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload }: PayloadAction<Record<string, any>>) => void;
+    handleNext: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload }: PayloadAction<Record<string, any>>) => void;
+    focusStep: (state: import("immer/dist/internal").WritableDraft<SiteState>, { payload, }: PayloadAction<{
+        step: FormStep;
+        values: FieldValues;
+    } | undefined>) => void;
+}, "site">;
+export declare const focusStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    step: FormStep;
+    values: FieldValues;
+} | undefined, "site/focusStep">, clearDependency: import("@reduxjs/toolkit").ActionCreatorWithPayload<GBaseStep, "site/clearDependency">, setStepDependency: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    step: GBaseStep;
+    value: StepDependency['value'];
+}, "site/setStepDependency">, addStepsDependencies: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    steps: Record<string, FormStep | CBRFormStep>;
+    customSteps: Record<string, CustomStep>;
+    allSteps: Record<string, FormStep | CBRFormStep>;
+}, "site/addStepsDependencies">, setEmptyDependency: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    step: GBaseStep;
+    empty: StepDependency['empty'];
+}, "site/setEmptyDependency">, handlePrevious: import("@reduxjs/toolkit").ActionCreatorWithPayload<Record<string, any>, "site/handlePrevious">, handleNext: import("@reduxjs/toolkit").ActionCreatorWithPayload<Record<string, any>, "site/handleNext">;
+export default SiteSlice;

package/dist/mjs/States/SiteSlice.js

@@ -0,0 +1,116 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { reset } from './GlobalSlice';
+import { calcDependencies } from '../Form/FormFunctions';
+import { calcDefaultValue } from '../FormSteps/StepFunctions';
+const initialState = {
+    values: {
+        global: {},
+        sections: {},
+    },
+    dependencies: {},
+    idCurrentSection: null,
+    previousSections: [],
+    nextSections: [],
+};
+export const SiteSlice = createSlice({
+    name: 'site',
+    initialState,
+    reducers: {
+        setStepDependency: (state, { payload: { step: { id, type, idSection }, value, }, }) => {
+            const old = state.dependencies[id];
+            if (old && (old.type !== type || old.value !== value)) {
+                state.dependencies[id] = {
+                    ...state.dependencies[id],
+                    type: type,
+                    value,
+                };
+                if (state.idCurrentSection !== null) {
+                    for (const dependent of old.dependents) {
+                        if (dependent.idSection !== idSection) {
+                            state.values.sections[dependent.idSection][dependent.id] = calcDefaultValue(dependent);
+                        }
+                    }
+                }
+            }
+        },
+        clearDependency: (state, { payload: { id, idSection } }) => {
+            if (state.idCurrentSection === null ||
+                state.idCurrentSection === idSection) {
+                const old = state.dependencies[id];
+                if (old && old.value !== null) {
+                    state.dependencies[id] = {
+                        ...state.dependencies[id],
+                        value: null,
+                        empty: false,
+                    };
+                    if (state.idCurrentSection !== null) {
+                        for (const dependent of old.dependents) {
+                            if (dependent.idSection !== idSection) {
+                                state.values.sections[dependent.idSection][dependent.id] = calcDefaultValue(dependent);
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        setEmptyDependency: (state, { payload: { step: { id }, empty, }, }) => {
+            if (state.dependencies[id]) {
+                state.dependencies[id].empty = empty;
+            }
+        },
+        addStepsDependencies: (state, { payload: { steps, customSteps, allSteps }, }) => {
+            calcDependencies(steps, customSteps, allSteps, state.dependencies);
+        },
+        handlePrevious: (state, { payload }) => {
+            const { previousSections, nextSections, idCurrentSection } = state;
+            const idPreviousSection = previousSections.pop();
+            if (!idPreviousSection || !idCurrentSection)
+                return;
+            nextSections.unshift(idCurrentSection);
+            state.values.sections[idCurrentSection] = payload;
+            state.idCurrentSection = idPreviousSection;
+        },
+        handleNext: (state, { payload }) => {
+            const { previousSections, nextSections, idCurrentSection } = state;
+            const idNextSection = nextSections.shift();
+            if (!idNextSection || !idCurrentSection)
+                return;
+            previousSections.push(idCurrentSection);
+            state.values.sections[idCurrentSection] = payload;
+            state.idCurrentSection = idNextSection;
+        },
+        focusStep: (state, { payload, }) => {
+            const idSection = payload?.step.idSection;
+            const { previousSections, nextSections } = state;
+            let idCurrentSection = state.idCurrentSection;
+            if (idSection &&
+                idCurrentSection &&
+                previousSections.includes(idSection)) {
+                state.values.sections[idCurrentSection] = payload.values;
+                while (idCurrentSection !== idSection) {
+                    const idPreviousSection = previousSections.pop();
+                    if (!idCurrentSection)
+                        return;
+                    nextSections.unshift(idCurrentSection);
+                    idCurrentSection = idPreviousSection;
+                }
+            }
+            state.previousSections = previousSections;
+            state.idCurrentSection = idCurrentSection;
+            state.nextSections = nextSections;
+            state.focusStep = payload?.step.id;
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(reset, (state, action) => {
+            const payload = action.payload;
+            state.previousSections = payload.previousSections;
+            state.idCurrentSection = payload.idCurrentSection;
+            state.nextSections = payload.nextSections;
+            state.values = payload.values;
+            state.dependencies = payload.dependencies;
+        });
+    },
+});
+export const { focusStep, clearDependency, setStepDependency, addStepsDependencies, setEmptyDependency, handlePrevious, handleNext, } = SiteSlice.actions;
+export default SiteSlice;

package/dist/mjs/States/WidthStatsSlice.d.ts

@@ -0,0 +1,7 @@
+import { WidthStats } from '../Form/Form';
+import type { PayloadAction } from '@reduxjs/toolkit';
+export declare const WidthStatsSlice: import("@reduxjs/toolkit").Slice<WidthStats, {
+    updateWidthStats: (state: import("immer/dist/internal").WritableDraft<WidthStats>, { payload }: PayloadAction<WidthStats>) => WidthStats;
+}, "widthStats">;
+export declare const updateWidthStats: import("@reduxjs/toolkit").ActionCreatorWithPayload<WidthStats, "widthStats/updateWidthStats">;
+export default WidthStatsSlice;

package/dist/mjs/States/WidthStatsSlice.js

@@ -0,0 +1,22 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {
+    currentBreakPoint: 0,
+    isMobile: false,
+    isResponsive: false,
+};
+export const WidthStatsSlice = createSlice({
+    name: 'widthStats',
+    initialState,
+    reducers: {
+        updateWidthStats: (state, { payload }) => {
+            if (payload.isMobile !== state?.isMobile ||
+                payload.isResponsive !== state?.isResponsive ||
+                payload.currentBreakPoint !== state?.currentBreakPoint)
+                return payload;
+            else
+                return state;
+        },
+    },
+});
+export const { updateWidthStats } = WidthStatsSlice.actions;
+export default WidthStatsSlice;

package/dist/mjs/Utils/AxiosAPI.d.ts

@@ -0,0 +1,2 @@
+declare const axiosInstance: import("axios").AxiosInstance;
+export default axiosInstance;

package/dist/mjs/Utils/AxiosAPI.js

@@ -0,0 +1,8 @@
+import axios from 'axios';
+const headers = {};
+const axiosInstance = axios.create({
+    baseURL: '/api',
+    timeout: 30000,
+    headers,
+});
+export default axiosInstance;

package/dist/mjs/Utils/AxiosWidget.d.ts

@@ -0,0 +1,2 @@
+declare const widgetInstance: import("axios").AxiosInstance;
+export default widgetInstance;

package/dist/mjs/Utils/AxiosWidget.js

@@ -0,0 +1,8 @@
+import axios from 'axios';
+const headers = {};
+const widgetInstance = axios.create({
+    baseURL: `https://api.forms.${process.env.REACT_APP_DOMAIN}/api`,
+    timeout: 30000,
+    headers,
+});
+export default widgetInstance;

package/dist/mjs/Utils/CBRFunctions.d.ts

@@ -0,0 +1,8 @@
+import { Form } from '../@Types';
+export interface Incident {
+    idSpaceStep: string;
+    idElementStep: string;
+    idCommentStep: string;
+    num: number;
+}
+export declare const calcCbrForm: (form: Form, formValues: Record<string, any>) => Form;

package/dist/mjs/Utils/CBRFunctions.js

@@ -0,0 +1,52 @@
+import CBRFormStepTypes from '../constants/CBRFormStepTypes';
+export const calcCbrForm = (form, formValues) => {
+    for (const step of Object.values(form.steps)) {
+        if (step.type === CBRFormStepTypes.CBR_INCIDENCIAS) {
+            const incidentStep = step;
+            const incValue = formValues[incidentStep.id ?? ''];
+            if (incValue) {
+                for (const incident of incValue) {
+                    handleAddIncident(incident, incidentStep, form.steps, formValues);
+                }
+            }
+        }
+    }
+    return form;
+};
+const handleAddIncident = (incident, step, steps, formValues) => {
+    const spaceStep = {
+        ...step.spaceStep,
+        id: incident.idSpaceStep,
+        type: CBRFormStepTypes.CBR_TIPO_ESPACIO,
+        dependencies: step.dependencies,
+    };
+    steps[incident.idSpaceStep] = spaceStep;
+    const commentStep = {
+        ...step.commentStep,
+        id: incident.idCommentStep,
+        type: CBRFormStepTypes.CBR_COMENTARIO,
+    };
+    steps[incident.idCommentStep] = commentStep;
+    addRecursiveElementStep(incident.idElementStep, step.elementStep, null, steps, step.dependencies?.[0] ?? '', formValues);
+};
+const addRecursiveElementStep = (idStep, step, idParent, steps, idProjectDep, formValues) => {
+    const idSubStep = formValues[idStep]?.subStep;
+    const newSubStep = step.subStep ? { ...step.subStep } : undefined;
+    const newStep = {
+        ...step,
+        id: idStep,
+        type: CBRFormStepTypes.CBR_LOCATIVAS,
+        dependencies: [idProjectDep],
+        subStep: null,
+    };
+    if (newSubStep) {
+        newStep.subStep = idSubStep;
+    }
+    if (idParent) {
+        newStep.dependencies?.push?.(idParent);
+    }
+    steps[idStep] = newStep;
+    if (newSubStep) {
+        addRecursiveElementStep(idSubStep, newSubStep, idStep, steps, idProjectDep, formValues);
+    }
+};

package/dist/mjs/Utils/DraftFunctions.d.ts

@@ -0,0 +1,3 @@
+import { RawDraftContentState } from 'draft-js';
+export declare function stringToDraft(text: string): RawDraftContentState;
+export declare const getRawText: (draft?: RawDraftContentState, text?: string) => RawDraftContentState;

package/dist/mjs/Utils/DraftFunctions.js

@@ -0,0 +1,43 @@
+import { nanoid } from '@reduxjs/toolkit';
+export function stringToDraft(text) {
+    const draftStructure = {
+        blocks: [],
+        entityMap: {},
+    };
+    text.split('\n').forEach((element, index) => {
+        draftStructure.blocks.push({
+            key: String(index),
+            text: element,
+            type: 'unstyled',
+            depth: 0,
+            inlineStyleRanges: [],
+            entityRanges: [],
+            data: {},
+        });
+    });
+    return draftStructure;
+}
+export const getRawText = (draft, text) => {
+    if (draft !== undefined) {
+        return draft;
+    }
+    else if (text !== undefined) {
+        return stringToDraft(text);
+    }
+    else {
+        return {
+            blocks: [
+                {
+                    key: nanoid(5),
+                    text: '',
+                    type: 'unstyled',
+                    depth: 0,
+                    inlineStyleRanges: [],
+                    entityRanges: [],
+                    data: {},
+                },
+            ],
+            entityMap: {},
+        };
+    }
+};

package/dist/mjs/Utils/MaterialProviders.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface MaterialProvidersProps {
+    children: React.ReactNode;
+}
+declare function MaterialProviders({ children }: MaterialProvidersProps): JSX.Element;
+export default MaterialProviders;

package/dist/mjs/Utils/MaterialProviders.js

@@ -0,0 +1,19 @@
+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';
+const muiTheme = createTheme({
+    typography: {
+        fontFamily: 'inherit',
+    },
+});
+const generateClassName = createGenerateClassName({
+    seed: SEED,
+    productionPrefix: 'efjss',
+});
+function MaterialProviders({ children }) {
+    return (_jsx(StylesProvider, { generateClassName: generateClassName, children: _jsx(ThemeProvider, { theme: muiTheme, children: _jsx(MuiPickersUtilsProvider, { utils: DateFnsUtils, locale: getLocale(), children: children }) }) }));
+}
+export default MaterialProviders;