@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/reducers/app.test.js

@@ -0,0 +1,166 @@
+import { appReducer } from './app';
+const appStateMock = {
+    meta: {
+        fetchStatus: 'waiting',
+        id: 0,
+        prefix: '',
+        permalink: 'permalink',
+        title: 'title',
+        modelVersion: 1,
+        productType: 'demarche',
+    },
+    wizard: {
+        availableSections: [1, 2, 3],
+        currentSectionId: 1,
+    },
+    pagination: {
+        currentPage: 1,
+        greatestPage: 1,
+        currentAppState: 'wizard',
+        availableAppStates: ['wizard'],
+        isFirstPage: true,
+        isLastPage: false,
+        totalPages: 3,
+    },
+    instance: {
+        companyId: undefined,
+        employeeId: undefined,
+        dataStatus: 'saved',
+        uniqid: '3jHD42343sDE',
+        isOrderHandled: undefined,
+        isPaid: false,
+        steps: '*',
+    },
+    customization: {},
+};
+describe('App Reducer test suit', () => {
+    it('Combines meta reducer', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'INIT_META',
+            prefix: '',
+            id: 123,
+            permalink: 'some-other-permalink',
+            title: 'Some other title',
+            modelVersion: 1,
+            productType: 'demarche',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { meta: {
+                fetchStatus: 'waiting',
+                id: 123,
+                prefix: '',
+                permalink: 'some-other-permalink',
+                title: 'Some other title',
+                modelVersion: 1,
+                productType: 'demarche',
+            } }));
+    });
+    it('Combines pagination reducer', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'INIT_PAGINATION',
+            currentPage: 11,
+            currentSectionId: 13,
+            greatestPage: 11,
+            availableSections: [1, 12, 13, 14, 15],
+            currentAppState: 'wizard',
+            availableAppStates: ['wizard'],
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { pagination: {
+                currentPage: 11,
+                greatestPage: 11,
+                currentAppState: 'wizard',
+                availableAppStates: ['wizard'],
+                isFirstPage: false,
+                isLastPage: false,
+                totalPages: 5,
+            }, wizard: {
+                currentSectionId: 13,
+                availableSections: [1, 12, 13, 14, 15],
+            } }));
+    });
+    it('Combines instance reducer', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'INIT_INSTANCE',
+            dataStatus: 'saved',
+            uniqid: 'SomeUniqid123',
+            isPaid: true,
+            steps: '*',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { instance: {
+                dataStatus: 'saved',
+                uniqid: 'SomeUniqid123',
+                isOrderHandled: undefined,
+                employeeId: undefined,
+                companyId: undefined,
+                isPaid: true,
+                steps: '*',
+            } }));
+    });
+    it('App Reducer INIT_INSTANCE Action', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'INIT_INSTANCE',
+            dataStatus: 'saved',
+            uniqid: '3jHD42343sDE',
+            isPaid: false,
+            steps: '*',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { instance: {
+                dataStatus: 'saved',
+                isOrderHandled: undefined,
+                employeeId: undefined,
+                companyId: undefined,
+                uniqid: '3jHD42343sDE',
+                isPaid: false,
+                steps: '*',
+            } }));
+    });
+    it('App Reducer UPDATE_INSTANCE_PAID Action', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'UPDATE_INSTANCE_PAID',
+            isPaid: true,
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { instance: Object.assign(Object.assign({}, appStateMock.instance), { isPaid: true }) }));
+    });
+    it('appReducer INIT_PAGINATION Action', () => {
+        const reducer = appReducer(appStateMock, {
+            type: 'INIT_PAGINATION',
+            currentSectionId: 32,
+            currentPage: 32,
+            greatestPage: 32,
+            availableSections: [32, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 32, greatestPage: 32, availableAppStates: ['wizard'], currentAppState: 'wizard', isFirstPage: false }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 32, availableSections: [32, 2, 3] }) }));
+    });
+    it('appReducer GO_PAGE Action', () => {
+        const state = Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 1, greatestPage: 1 }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 1, availableSections: [1, 6, 3] }) });
+        const reducer = appReducer(state, {
+            type: 'GO_PAGE',
+            currentPage: 2,
+            pushHistory: false,
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 2, greatestPage: 2, isFirstPage: false }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 6, availableSections: [1, 6, 3] }) }));
+    });
+    it('appReducer UPDATE_AVAILABLE_SECTIONS Action', () => {
+        const state = Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 1, greatestPage: 14 }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 1, availableSections: [1, 2, 3] }) });
+        const reducer = appReducer(state, {
+            type: 'UPDATE_AVAILABLE_SECTIONS',
+            availableSections: [1, 3, 4],
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 1, greatestPage: 14 }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 1, availableSections: [1, 3, 4] }) }));
+    });
+    it('appReducer GO_NEXT_PAGE Action', () => {
+        const state = Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 1, greatestPage: 1 }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 1, availableSections: [1, 6, 3] }) });
+        const reducer = appReducer(state, {
+            type: 'GO_NEXT_PAGE',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 2, greatestPage: 2, isFirstPage: false }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 6, availableSections: [1, 6, 3] }) }));
+    });
+    it('appReducer GO_PREVIOUS_PAGE Action', () => {
+        const state = Object.assign(Object.assign({}, appStateMock), { pagination: Object.assign(Object.assign({}, appStateMock.pagination), { currentPage: 3, greatestPage: 3, isFirstPage: false }), wizard: Object.assign(Object.assign({}, appStateMock.wizard), { currentSectionId: 3, availableSections: [1, 5, 3] }) });
+        const reducer = appReducer(state, {
+            type: 'GO_PREVIOUS_PAGE',
+        });
+        return expect(reducer).toStrictEqual(Object.assign(Object.assign({}, state), { pagination: Object.assign(Object.assign({}, state.pagination), { currentPage: 2, greatestPage: 3 }), wizard: Object.assign(Object.assign({}, state.wizard), { currentSectionId: 5, availableSections: [1, 5, 3] }) }));
+    });
+});

package/dist/redux/reducers/conditions/addMultipleOccurency.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const addMultipleOccurencyReducer: (state: StateType.Conditions, action: ActionsType.Inputs.addMultipleOccurency) => StateType.Conditions;

package/dist/redux/reducers/conditions/addMultipleOccurency.js

@@ -0,0 +1,68 @@
+import ConditionsMapper from '@legalplace/referencesparser/dist/libs/ConditionsMapper';
+export const addMultipleOccurencyReducer = (state, action) => {
+    const { id, optionRelations, prefillersVariables } = action;
+    if (optionRelations === undefined || prefillersVariables === undefined)
+        throw new Error('ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding ' +
+            `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+            'plugged and working properly');
+    const conditionnedOptions = Object.keys(state.options).map((currentId) => parseInt(currentId, 10));
+    const conditionnedVariables = Object.keys(state.variables).map((currentId) => parseInt(currentId, 10));
+    const conditionnedOptionsValidators = Object.keys(state.validators.options).map((currentId) => parseInt(currentId, 10));
+    const conditionnedVariablesValidators = Object.keys(state.validators.variables).map((currentId) => parseInt(currentId, 10));
+    const conditionnedPrefillers = Object.keys(state.prefillers).map((currentId) => parseInt(currentId, 10));
+    const optionsIds = [
+        id,
+        ...optionRelations.children.options,
+        ...optionRelations.dependants,
+    ].filter((currentId) => conditionnedOptions.includes(currentId));
+    const variablesIds = optionRelations.children.variables.filter((currentId) => conditionnedVariables.includes(currentId));
+    const optionsValidatorsIds = optionRelations.children.options.filter((currentId) => conditionnedOptionsValidators.includes(currentId));
+    const variablesValidatorsIds = optionRelations.children.variables.filter((currentId) => conditionnedVariablesValidators.includes(currentId));
+    const prefillersIds = optionRelations.children.variables.filter((currentId) => conditionnedPrefillers.includes(currentId));
+    const options = {};
+    optionsIds.forEach((currentOptionId) => {
+        options[currentOptionId] = [...state.options[currentOptionId], false];
+    });
+    const variables = {};
+    variablesIds.forEach((currentVariableId) => {
+        variables[currentVariableId] = [
+            ...state.variables[currentVariableId],
+            false,
+        ];
+    });
+    const optionsValidators = {};
+    optionsValidatorsIds.forEach((currentOptionId) => {
+        optionsValidators[currentOptionId] = [
+            ...state.validators.options[currentOptionId],
+            false,
+        ];
+    });
+    const variablesValidators = {};
+    variablesValidatorsIds.forEach((currentVariableId) => {
+        variablesValidators[currentVariableId] = [
+            ...state.validators.variables[currentVariableId],
+            false,
+        ];
+    });
+    const prefillers = {};
+    prefillersIds.forEach((currentVariableId) => {
+        const variablePrefillings = prefillersVariables[currentVariableId];
+        const defaultPrefillersValues = Array.isArray(variablePrefillings)
+            ? new Array(variablePrefillings.length).fill(false)
+            : [true];
+        variablePrefillings === null || variablePrefillings === void 0 ? void 0 : variablePrefillings.forEach((prefilling, index) => {
+            if (!prefilling.conditions ||
+                (prefilling.conditions &&
+                    ConditionsMapper.countConditions(prefilling.conditions) === 0))
+                defaultPrefillersValues[index] = true;
+        });
+        prefillers[currentVariableId] = [
+            ...state.prefillers[currentVariableId],
+            defaultPrefillersValues,
+        ];
+    });
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), variables), prefillers: Object.assign(Object.assign({}, state.prefillers), prefillers), options: Object.assign(Object.assign({}, state.options), options), validators: {
+            options: Object.assign(Object.assign({}, state.validators.options), optionsValidators),
+            variables: Object.assign(Object.assign({}, state.validators.variables), variablesValidators),
+        } });
+};

package/dist/redux/reducers/conditions/addMultipleOccurency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/reducers/conditions/addMultipleOccurency.test.js

@@ -0,0 +1,108 @@
+import { addMultipleOccurencyReducer } from './addMultipleOccurency';
+const state = {
+    options: {
+        4: [true],
+    },
+    variables: {
+        2: [false],
+    },
+    validators: {
+        options: {
+            4: [false],
+        },
+        variables: {
+            3: [false],
+        },
+    },
+    documents: {},
+    sections: {},
+    prefillers: {
+        3: [[false, false, false]],
+    },
+};
+describe('addMultipleOccurencyReducer test suit', () => {
+    it('Throws an error if optionRelations or prefillersVariables are undefined', () => {
+        expect(() => {
+            addMultipleOccurencyReducer(state, {
+                id: 3,
+                optionRelations: undefined,
+                prefillersVariables: undefined,
+            });
+        }).toThrowError('ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding occurency for 3,' +
+            ' please make sure "multiplesActions" middleware is plugged and working properly');
+    });
+    it('Adds a multiple occurency conditions correctly', () => {
+        const optionRelations = {
+            options: [],
+            variables: [],
+            sections: {},
+            documents: [],
+            prefillers: [],
+            validators: {
+                options: [],
+                variables: [],
+            },
+            parents: [],
+            children: {
+                options: [3, 4],
+                variables: [2, 3],
+            },
+            dependants: [7, 8],
+        };
+        const prefillersVariables = {
+            '3': [
+                {
+                    value: 'Option 2 selected',
+                    conditions: {
+                        selected: [
+                            {
+                                var: 'o.4',
+                            },
+                        ],
+                    },
+                },
+                {
+                    value: 'Option 1 selected',
+                    conditions: {
+                        selected: [
+                            {
+                                var: 'o.3',
+                            },
+                        ],
+                    },
+                },
+                {
+                    value: 'Variable 1 = Hello',
+                    conditions: {
+                        contains: [
+                            {
+                                var: 'v.1',
+                            },
+                            'Hello',
+                        ],
+                    },
+                },
+            ],
+        };
+        const reducerResult = addMultipleOccurencyReducer(state, {
+            id: 2,
+            optionRelations,
+            prefillersVariables,
+        });
+        expect(reducerResult).toStrictEqual(Object.assign(Object.assign({}, state), { options: Object.assign(Object.assign({}, state.options), { 4: [true, false] }), variables: {
+                2: [false, false],
+            }, prefillers: {
+                3: [
+                    [false, false, false],
+                    [false, false, false],
+                ],
+            }, validators: {
+                options: {
+                    4: [false, false],
+                },
+                variables: {
+                    3: [false, false],
+                },
+            } }));
+    });
+});

package/dist/redux/reducers/conditions/deleteMultipleOccurency.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const deleteMultipleOccurencyReducer: (state: StateType.Conditions, action: ActionsType.Inputs.deleteMultipleOccurency) => StateType.Conditions;

package/dist/redux/reducers/conditions/deleteMultipleOccurency.js

@@ -0,0 +1,56 @@
+export const deleteMultipleOccurencyReducer = (state, action) => {
+    const { id, index, optionRelations } = action;
+    if (optionRelations === undefined)
+        throw new Error('DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing ' +
+            `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+            'plugged and working properly');
+    const conditionnedOptions = Object.keys(state.options).map((currentId) => parseInt(currentId, 10));
+    const conditionnedVariables = Object.keys(state.variables).map((currentId) => parseInt(currentId, 10));
+    const conditionnedOptionsValidators = Object.keys(state.validators.options).map((currentId) => parseInt(currentId, 10));
+    const conditionnedVariablesValidators = Object.keys(state.validators.variables).map((currentId) => parseInt(currentId, 10));
+    const conditionnedPrefillers = Object.keys(state.prefillers).map((currentId) => parseInt(currentId, 10));
+    const optionsIds = [id, ...optionRelations.children.options].filter((currentId) => conditionnedOptions.includes(currentId));
+    const variablesIds = optionRelations.children.variables.filter((currentId) => conditionnedVariables.includes(currentId));
+    const optionsValidatorsIds = optionRelations.children.options.filter((currentId) => conditionnedOptionsValidators.includes(currentId));
+    const variablesValidatorsIds = optionRelations.children.variables.filter((currentId) => conditionnedVariablesValidators.includes(currentId));
+    const prefillersIds = optionRelations.children.variables.filter((currentId) => conditionnedPrefillers.includes(currentId));
+    const options = {};
+    optionsIds.forEach((currentOptionId) => {
+        options[currentOptionId] = [
+            ...state.options[currentOptionId].slice(0, index),
+            ...state.options[currentOptionId].slice(index + 1),
+        ];
+    });
+    const variables = {};
+    variablesIds.forEach((currentVariableId) => {
+        variables[currentVariableId] = [
+            ...state.variables[currentVariableId].slice(0, index),
+            ...state.variables[currentVariableId].slice(index + 1),
+        ];
+    });
+    const optionsValidators = {};
+    optionsValidatorsIds.forEach((currentOptionId) => {
+        optionsValidators[currentOptionId] = [
+            ...state.validators.options[currentOptionId].slice(0, index),
+            ...state.validators.options[currentOptionId].slice(index + 1),
+        ];
+    });
+    const variablesValidators = {};
+    variablesValidatorsIds.forEach((currentVariableId) => {
+        variablesValidators[currentVariableId] = [
+            ...state.validators.variables[currentVariableId].slice(0, index),
+            ...state.validators.variables[currentVariableId].slice(index + 1),
+        ];
+    });
+    const prefillers = {};
+    prefillersIds.forEach((currentVariableId) => {
+        prefillers[currentVariableId] = [
+            ...state.prefillers[currentVariableId].slice(0, index),
+            ...state.prefillers[currentVariableId].slice(index + 1),
+        ];
+    });
+    return Object.assign(Object.assign({}, state), { variables: Object.assign(Object.assign({}, state.variables), variables), prefillers: Object.assign(Object.assign({}, state.prefillers), prefillers), options: Object.assign(Object.assign({}, state.options), options), validators: {
+            options: Object.assign(Object.assign({}, state.validators.options), optionsValidators),
+            variables: Object.assign(Object.assign({}, state.validators.variables), variablesValidators),
+        } });
+};

package/dist/redux/reducers/conditions/deleteMultipleOccurency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/reducers/conditions/deleteMultipleOccurency.test.js

@@ -0,0 +1,77 @@
+import { deleteMultipleOccurencyReducer } from './deleteMultipleOccurency';
+const state = {
+    options: {
+        4: [true, false, true],
+    },
+    variables: {
+        2: [false, true, false],
+    },
+    validators: {
+        options: {
+            4: [false, false, true],
+        },
+        variables: {
+            3: [true, false, true],
+        },
+    },
+    documents: {},
+    sections: {},
+    prefillers: {
+        3: [
+            [true, false, false],
+            [false, true, false],
+            [false, false, true],
+        ],
+    },
+};
+describe('deleteMultipleOccurencyReducer test suit', () => {
+    it('Throws an error if optionRelations or prefillersVariables are undefined', () => {
+        expect(() => {
+            deleteMultipleOccurencyReducer(state, {
+                id: 3,
+                optionRelations: undefined,
+            });
+        }).toThrowError('DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing occurency for 3,' +
+            ' please make sure "multiplesActions" middleware is plugged and working properly');
+    });
+    it('Adds a multiple occurency conditions correctly', () => {
+        const optionRelations = {
+            options: [],
+            variables: [],
+            sections: {},
+            documents: [],
+            prefillers: [],
+            validators: {
+                options: [],
+                variables: [],
+            },
+            parents: [],
+            children: {
+                options: [3, 4],
+                variables: [2, 3],
+            },
+            dependants: [7, 8],
+        };
+        const reducerResult = deleteMultipleOccurencyReducer(state, {
+            id: 2,
+            index: 1,
+            optionRelations,
+            type: 'DELETE_MULTIPLE_OCCURENCY',
+        });
+        expect(reducerResult).toStrictEqual(Object.assign(Object.assign({}, state), { options: Object.assign(Object.assign({}, state.options), { 4: [true, true] }), variables: {
+                2: [false, false],
+            }, prefillers: {
+                3: [
+                    [true, false, false],
+                    [false, false, true],
+                ],
+            }, validators: {
+                options: {
+                    4: [false, true],
+                },
+                variables: {
+                    3: [true, true],
+                },
+            } }));
+    });
+});

package/dist/redux/reducers/conditions/initConditions.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const initConditionsReducer: (state: StateType.Conditions, action: ActionsType.Conditions.initConditions) => StateType.Conditions;

package/dist/redux/reducers/conditions/initConditions.js

@@ -0,0 +1,11 @@
+export const initConditionsReducer = (state, action) => {
+    const { options, variables, sections, prefillers, validators, documents } = action;
+    return {
+        options,
+        variables,
+        sections,
+        prefillers,
+        validators,
+        documents,
+    };
+};

package/dist/redux/reducers/conditions/updateDocumentConditions.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateDocumentConditionReducer: (state: StateType.Conditions, action: ActionsType.Conditions.updateDocumentCondition) => StateType.Conditions;

package/dist/redux/reducers/conditions/updateDocumentConditions.js

@@ -0,0 +1,6 @@
+export const updateDocumentConditionReducer = (state, action) => {
+    const { name, value } = action;
+    if (state.documents[name] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { documents: Object.assign(Object.assign({}, state.documents), { [name]: value }) });
+};

package/dist/redux/reducers/conditions/updateDocumentConditions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/reducers/conditions/updateDocumentConditions.test.js

@@ -0,0 +1,35 @@
+import { updateDocumentConditionReducer } from './updateDocumentConditions';
+import { UPDATE_DOCUMENT_CONDITION } from '../../constants/conditions';
+const state = {
+    options: {},
+    variables: {},
+    validators: {
+        options: {},
+        variables: {},
+    },
+    documents: {
+        'test-document-1': true,
+        'test-document-2': false,
+        'test-document-3': true,
+    },
+    sections: {},
+    prefillers: {},
+};
+describe('updateDocumentConditionReducer test suit', () => {
+    it('Updates document condition properly', () => {
+        const reducerResult = updateDocumentConditionReducer(state, {
+            type: UPDATE_DOCUMENT_CONDITION,
+            name: 'test-document-2',
+            value: true,
+        });
+        expect(reducerResult).toStrictEqual(Object.assign(Object.assign({}, state), { documents: Object.assign(Object.assign({}, state.documents), { 'test-document-2': true }) }));
+    });
+    it('Returns same state without touching references if condition did not change', () => {
+        const reducerResult = updateDocumentConditionReducer(state, {
+            type: UPDATE_DOCUMENT_CONDITION,
+            name: 'test-document-2',
+            value: false,
+        });
+        expect(reducerResult).toEqual(state);
+    });
+});

package/dist/redux/reducers/conditions/updateOptionConditions.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateOptionConditionReducer: (state: StateType.Conditions, action: ActionsType.Conditions.updateOptionCondition) => StateType.Conditions;

package/dist/redux/reducers/conditions/updateOptionConditions.js

@@ -0,0 +1,10 @@
+export const updateOptionConditionReducer = (state, action) => {
+    const { id, value, index } = action;
+    if (state.options[id][index] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { options: Object.assign(Object.assign({}, state.options), { [id]: [
+                ...state.options[id].slice(0, index),
+                value,
+                ...state.options[id].slice(index + 1),
+            ] }) });
+};

package/dist/redux/reducers/conditions/updateOptionValidatorCondition.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateOptionValidatorConditionReducer: (state: StateType.Conditions, action: ActionsType.Conditions.updateOptionValidatorCondition) => StateType.Conditions;

package/dist/redux/reducers/conditions/updateOptionValidatorCondition.js

@@ -0,0 +1,10 @@
+export const updateOptionValidatorConditionReducer = (state, action) => {
+    const { id, value, index } = action;
+    if (state.validators.options[id][index] === value)
+        return state;
+    return Object.assign(Object.assign({}, state), { validators: Object.assign(Object.assign({}, state.validators), { options: Object.assign(Object.assign({}, state.validators.options), { [id]: [
+                    ...state.validators.options[id].slice(0, index),
+                    value,
+                    ...state.validators.options[id].slice(index + 1),
+                ] }) }) });
+};

package/dist/redux/reducers/conditions/updateOptionValidatorCondition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/redux/reducers/conditions/updateOptionValidatorCondition.test.js

@@ -0,0 +1,35 @@
+import { updateOptionValidatorConditionReducer } from './updateOptionValidatorCondition';
+import { UPDATE_OPTION_VALIDATOR_CONDITION } from '../../constants/conditions';
+const state = {
+    options: {},
+    variables: {},
+    validators: {
+        options: {
+            2: [false, true, false],
+        },
+        variables: {},
+    },
+    documents: {},
+    sections: {},
+    prefillers: {},
+};
+describe('updateOptionValidatorConditionReducer test suit', () => {
+    it('Updates option validator condition properly', () => {
+        const reducerResult = updateOptionValidatorConditionReducer(state, {
+            type: UPDATE_OPTION_VALIDATOR_CONDITION,
+            id: 2,
+            index: 1,
+            value: false,
+        });
+        expect(reducerResult).toStrictEqual(Object.assign(Object.assign({}, state), { validators: Object.assign(Object.assign({}, state.validators), { options: Object.assign(Object.assign({}, state.validators.options), { 2: [false, false, false] }) }) }));
+    });
+    it('Returns same state without touching references if condition did not change', () => {
+        const reducerResult = updateOptionValidatorConditionReducer(state, {
+            type: UPDATE_OPTION_VALIDATOR_CONDITION,
+            id: 2,
+            index: 1,
+            value: true,
+        });
+        expect(reducerResult).toEqual(state);
+    });
+});

package/dist/redux/reducers/conditions/updatePrefillerConditions.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updatePrefillerConditionReducer: (state: StateType.Conditions, action: ActionsType.Conditions.updatePrefillerCondition) => StateType.Conditions;

package/dist/redux/reducers/conditions/updatePrefillerConditions.js

@@ -0,0 +1,12 @@
+export const updatePrefillerConditionReducer = (state, action) => {
+    const { id, value, index } = action;
+    if (!state.prefillers[id][index] ||
+        state.prefillers[id][index].reduce((v, p) => v + p, '') ===
+            value.reduce((v, p) => v + p, ''))
+        return state;
+    return Object.assign(Object.assign({}, state), { prefillers: Object.assign(Object.assign({}, state.prefillers), { [id]: [
+                ...state.prefillers[id].slice(0, index),
+                value,
+                ...state.prefillers[id].slice(index + 1),
+            ] }) });
+};

package/dist/redux/reducers/conditions/updateSectionConditions.d.ts

@@ -0,0 +1,3 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+export declare const updateSectionConditionReducer: (state: StateType.Conditions, action: ActionsType.Conditions.updateSectionCondition) => StateType.Conditions;