@arquimedes.co/eureka-forms 3.0.31-test → 3.0.32

package/dist/FormSteps/StepFunctions.test.js

@@ -1,695 +0,0 @@
-import AYFFormStepTypes from '../constants/AYFFormStepTypes';
-import CBRFormStepTypes from '../constants/CBRFormStepTypes';
-import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
-import { describe, expect, test, vi } from 'vitest';
-import { calcDefaultValue, calcFillerSize, calcStepWidth, calcSubSteps, iterateNestedSteps } from './StepFunctions';
-import { stringToDraft } from '../Utils/DraftFunctions';
-describe('StepFunctions', function () {
-    describe('calcFillerSize', function () {
-        test('No maxSize', async () => {
-            const size = calcFillerSize({ type: FormStepTypes.SELECTOR }, {}, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('Selector with no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.SELECTOR,
-                    size: 3,
-                    maxSize: 3,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('Selector without nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.SELECTOR,
-                    size: 3,
-                    maxSize: 3,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                        },
-                    ],
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: {
-                    label: 'Option',
-                    value: 'option',
-                },
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('Selector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                            type: OptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    ],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: {
-                    label: 'Option',
-                    value: 'option',
-                },
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('Selector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                            type: OptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    ],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('ClassifierSelector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CLASSIFIER_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idClassifier: {
-                            label: 'Option',
-                            idClassifier: 'idClassifier',
-                            type: ClassifierOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: 'idClassifier',
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('ClassifierSelector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CLASSIFIER_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idClassifier: {
-                            label: 'Option',
-                            idClassifier: 'idClassifier',
-                            type: ClassifierOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('EntityValuePicker with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.ENTITYVALUEPICKER,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idEntityValue: {
-                            label: 'Option',
-                            idEntityValue: 'idEntityValue',
-                            type: EntityValueOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: 'idEntityValue',
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('EntityValuePicker with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.ENTITYVALUEPICKER,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idEntityValue: {
-                            label: 'Option',
-                            idEntityValue: 'idEntityValue',
-                            type: EntityValueOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('ApiSelector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.API_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idOption: {
-                            label: 'Option',
-                            idOption: 'idOption',
-                            type: ApiSelectorOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: 'idOption',
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('ApiSelector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.API_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idOption: {
-                            label: 'Option',
-                            idOption: 'idOption',
-                            type: ApiSelectorOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    },
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('Unchecked Checkbox with checked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    steps: ['idStep2'],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('Checked Checkbox with unchecked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    uncheckedSteps: ['idStep2'],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: true,
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(230);
-        });
-        test('Unchecked Checkbox with unchecked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    uncheckedSteps: ['idStep2'],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {}, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-        test('Checked Checkbox with checked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: FormStepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    steps: ['idStep2'],
-                },
-                idStep2: {
-                    id: 'idStep2',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const size = calcFillerSize(steps.idStep, steps, {
-                idStep: true,
-            }, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(0);
-        });
-    });
-    describe('calcStepWidth', function () {
-        test('Size as 1', async () => {
-            const size = calcStepWidth(1, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(210);
-        });
-        test('More than Size 1', async () => {
-            const size = calcStepWidth(2, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(440);
-        });
-    });
-    describe('calcDefaultValue', function () {
-        test('CheckBox', async () => {
-            const defaultValue = calcDefaultValue({
-                type: FormStepTypes.CHECKBOX,
-            });
-            expect(defaultValue).toBe(false);
-        });
-        test('Checkbox with defaultValue', async () => {
-            const step = {
-                type: FormStepTypes.CHECKBOX,
-                defaultValue: true,
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe(true);
-        });
-        test('Title step type', async () => {
-            const step = {
-                type: FormStepTypes.TITLE,
-                title: stringToDraft('Title'),
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toEqual(undefined);
-        });
-        test('Selector, TextInput, ClassifierSelector step types', async () => {
-            const step1 = {
-                type: FormStepTypes.SELECTOR,
-            };
-            const step2 = {
-                type: FormStepTypes.TEXTINPUT,
-            };
-            const step3 = {
-                type: FormStepTypes.CLASSIFIER_SELECTOR,
-            };
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-            expect(defaultValue1).toBe('');
-            expect(defaultValue2).toBe('');
-            expect(defaultValue3).toBe('');
-        });
-        test('Textarea step type with text editor', async () => {
-            const step = {
-                type: FormStepTypes.TEXTAREA,
-                hasTextEditor: true,
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue.blocks[0].text).toBe('');
-        });
-        test('Textarea step type without text editor', async () => {
-            const step = {
-                type: FormStepTypes.TEXTAREA,
-                hasTextEditor: false,
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe('');
-        });
-        test('Rating, DatePicker, ApiSelector, EntityValuePicker step types', async () => {
-            const step1 = {
-                type: FormStepTypes.RATING,
-            };
-            const step2 = {
-                type: FormStepTypes.DATEPICKER,
-            };
-            const step3 = {
-                type: FormStepTypes.API_SELECTOR,
-            };
-            const step4 = {
-                type: FormStepTypes.ENTITYVALUEPICKER,
-            };
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-            const defaultValue4 = calcDefaultValue(step4);
-            expect(defaultValue1).toBe(null);
-            expect(defaultValue2).toBe(null);
-            expect(defaultValue3).toBe(null);
-            expect(defaultValue4).toBe(null);
-        });
-        test('Mapper, FileUpload, CBRFormStep types', async () => {
-            const step1 = {
-                type: FormStepTypes.MAPPER,
-            };
-            const step2 = {
-                type: FormStepTypes.FILEUPLOAD,
-            };
-            const step3 = {
-                type: CBRFormStepTypes.CBR_INCIDENCIAS,
-            };
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-            expect(defaultValue1).toEqual({ elements: [], page: 0 });
-            expect(defaultValue2).toEqual([]);
-            expect(defaultValue3).toEqual([]);
-        });
-        test('Collapsible step type', async () => {
-            const step = {
-                type: FormStepTypes.COLLAPSIBLE,
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe(false);
-        });
-        test('Separator step type', async () => {
-            const step = {
-                type: FormStepTypes.SEPARATOR,
-            };
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBeUndefined();
-        });
-    });
-    describe('iterateNestedSteps', function () {
-        test('should iterate over nested steps', async () => {
-            const steps = {
-                idStep1: {
-                    id: 'idStep1',
-                    type: FormStepTypes.MAPPER,
-                    rootSteps: ['idStep2'],
-                    steps: {
-                        idStep2: {
-                            id: 'idStep2',
-                            type: FormStepTypes.SELECTOR,
-                            size: 1,
-                            options: [
-                                {
-                                    label: 'Option',
-                                    value: 'option',
-                                    type: OptionTypes.NESTED,
-                                    steps: ['idStep3'],
-                                },
-                            ],
-                        },
-                        idStep3: {
-                            id: 'idStep3',
-                            type: FormStepTypes.TEXTINPUT,
-                            size: 1,
-                        },
-                    },
-                },
-                idStep4: {
-                    id: 'idStep4',
-                    type: FormStepTypes.TEXTINPUT,
-                    size: 1,
-                },
-            };
-            const iterationMock = vi.fn();
-            iterateNestedSteps('idStep1', steps, iterationMock);
-            expect(iterationMock).toHaveBeenCalledTimes(3);
-            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1);
-            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1.steps.idStep2);
-            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1.steps.idStep3);
-        });
-    });
-});
-describe('calcSubSteps', () => {
-    test('should return an empty array for unknown step type', () => {
-        const steps = {
-            unknownStep: {
-                id: 'unknownStep',
-                type: 'UNKNOWN_TYPE',
-            },
-        };
-        const result = calcSubSteps('unknownStep', steps);
-        expect(result).toEqual([]);
-    });
-    test('should return nested steps for Selector type', () => {
-        const steps = {
-            selectorStep: {
-                id: 'selectorStep',
-                type: FormStepTypes.SELECTOR,
-                options: [
-                    {
-                        label: 'Option 1',
-                        value: 'option1',
-                        type: OptionTypes.NESTED,
-                        steps: ['nestedStep1', 'nestedStep2'],
-                    },
-                    {
-                        label: 'Option 2',
-                        value: 'option2',
-                        type: OptionTypes.DEFAULT,
-                    },
-                ],
-            },
-        };
-        const result = calcSubSteps('selectorStep', steps);
-        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
-    });
-    test('should return nested steps for ClassifierSelector type', () => {
-        const steps = {
-            classifierSelectorStep: {
-                id: 'classifierSelectorStep',
-                type: FormStepTypes.CLASSIFIER_SELECTOR,
-                options: {
-                    classifierOption1: {
-                        idClassifier: 'classifierOption1',
-                        type: ClassifierOptionTypes.NESTED,
-                        steps: ['nestedStep1', 'nestedStep2'],
-                    },
-                    classifierOption2: {
-                        idClassifier: 'classifierOption2',
-                        type: ClassifierOptionTypes.HIDE,
-                    },
-                },
-            },
-        };
-        const result = calcSubSteps('classifierSelectorStep', steps);
-        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
-    });
-    test('Rating with nested steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: FormStepTypes.RATING,
-                nestedSteps: [['idStep2'], ['idStep3']],
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2', 'idStep3']);
-    });
-    test('Collapsible with steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: FormStepTypes.COLLAPSIBLE,
-                steps: ['idStep2'],
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2']);
-    });
-    test('Checkbox with steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: FormStepTypes.CHECKBOX,
-                size: 1,
-                maxSize: 2,
-                steps: ['idStep2'],
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2']);
-    });
-    test('EntityValuePicker with nested steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: FormStepTypes.ENTITYVALUEPICKER,
-                options: {
-                    idEntityValue: {
-                        type: EntityValueOptionTypes.NESTED,
-                        steps: ['idStep2'],
-                    },
-                },
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2']);
-    });
-    test('CBRFormStep with subStep', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: CBRFormStepTypes.CBR_LOCATIVAS,
-                subStep: 'idStep2',
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2']);
-    });
-    test('AYFFormStep with idNitStep', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: AYFFormStepTypes.AYF_ICA_CITY,
-                idNitStep: 'idStep2',
-            },
-        };
-        const subSteps = calcSubSteps('idStep', steps);
-        expect(subSteps).toEqual(['idStep2']);
-    });
-});

package/dist/FormSteps/Utils/@StepFiller/StepFillerContext.d.ts

@@ -1 +0,0 @@
-export declare const SizeChangeContext: import("react").Context<(() => void) | undefined>;

package/dist/FormSteps/Utils/@StepFiller/StepFillerContext.js

@@ -1,2 +0,0 @@
-import { createContext } from 'react';
-export const SizeChangeContext = createContext(undefined);