@legalplace/wizardx-core 4.42.10-nightly.20251125120616 → 4.42.11

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/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/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/updateVariableValidatorCondition.test.d.ts

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

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

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

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

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

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

@@ -0,0 +1,196 @@
+import { initConditionsReducer } from './conditions/initConditions';
+import { INIT_CONDITIONS } from '../constants/conditions';
+import { updateOptionConditionReducer } from './conditions/updateOptionConditions';
+import { updateSectionConditionReducer } from './conditions/updateSectionConditions';
+import { updateVariableConditionReducer } from './conditions/updateVariableConditions';
+import { updatePrefillerConditionReducer } from './conditions/updatePrefillerConditions';
+import { conditionsReducer } from './conditions';
+const initialState = {
+    type: INIT_CONDITIONS,
+    options: {
+        1: [true, false],
+    },
+    variables: {
+        1: [false, true],
+    },
+    prefillers: {
+        1: [
+            [true, false],
+            [false, true],
+        ],
+    },
+    validators: {
+        options: {},
+        variables: {},
+    },
+    sections: {
+        main: {},
+    },
+    documents: {},
+};
+describe('Conditions reducer test suit', () => {
+    it('initConditions reducer', () => {
+        const reducer = initConditionsReducer(initialState, {
+            type: INIT_CONDITIONS,
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {
+                    1: true,
+                },
+            },
+            documents: {},
+        });
+        expect(reducer).toEqual({
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {
+                    1: true,
+                },
+            },
+            documents: {},
+        });
+    });
+    it('updateOptionConditions reducer', () => {
+        const reducer = updateOptionConditionReducer(initialState, {
+            type: 'UPDATE_OPTION_CONDITION',
+            value: false,
+            index: 0,
+            id: 1,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { options: {
+                1: [false, false],
+            } }));
+    });
+    it('updateSectionConditions reducer', () => {
+        const reducer = updateSectionConditionReducer(initialState, {
+            type: 'UPDATE_SECTION_CONDITION',
+            value: false,
+            document: 'main',
+            id: 1,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { sections: {
+                main: {
+                    1: false,
+                },
+            } }));
+    });
+    it('updateVariableCondition reducer', () => {
+        const reducer = updateVariableConditionReducer(initialState, {
+            type: 'UPDATE_VARIABLE_CONDITION',
+            value: true,
+            id: 1,
+            index: 0,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { variables: {
+                1: [true, true],
+            } }));
+    });
+    it('updatePrefillerCondition reducer', () => {
+        const reducer = updatePrefillerConditionReducer(initialState, {
+            type: 'UPDATE_PREFILLER_CONDITION',
+            value: [false, true],
+            id: 1,
+            index: 0,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { prefillers: {
+                1: [
+                    [false, true],
+                    [false, true],
+                ],
+            } }));
+    });
+    it('Conditions reducer INIT_CONDITIONS', () => {
+        const reducer = conditionsReducer(initialState, {
+            type: INIT_CONDITIONS,
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {
+                    1: true,
+                },
+            },
+            documents: {},
+        });
+        expect(reducer).toEqual({
+            options: {},
+            variables: {},
+            prefillers: {},
+            validators: {
+                options: {},
+                variables: {},
+            },
+            sections: {
+                main: {
+                    1: true,
+                },
+            },
+            documents: {},
+        });
+    });
+    it('Conditions reducer UPDATE_OPTION_CONDITION', () => {
+        const reducer = conditionsReducer(initialState, {
+            type: 'UPDATE_OPTION_CONDITION',
+            value: false,
+            index: 0,
+            id: 1,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { options: {
+                1: [false, false],
+            } }));
+    });
+    it('Conditions reducer UPDATE_SECTION_CONDITION', () => {
+        const reducer = conditionsReducer(initialState, {
+            type: 'UPDATE_SECTION_CONDITION',
+            document: 'main',
+            value: false,
+            id: 1,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { sections: {
+                main: {
+                    1: false,
+                },
+            } }));
+    });
+    it('Conditions reducer UPDATE_VARIABLE_CONDITION', () => {
+        const reducer = conditionsReducer(initialState, {
+            type: 'UPDATE_VARIABLE_CONDITION',
+            value: true,
+            id: 1,
+            index: 0,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { variables: {
+                1: [true, true],
+            } }));
+    });
+    it('Conditions reducer UPDATE_PREFILLER_CONDITION', () => {
+        const reducer = conditionsReducer(initialState, {
+            type: 'UPDATE_PREFILLER_CONDITION',
+            value: [false, true],
+            id: 1,
+            index: 0,
+        });
+        expect(reducer).toEqual(Object.assign(Object.assign({}, initialState), { prefillers: {
+                1: [
+                    [false, true],
+                    [false, true],
+                ],
+            } }));
+    });
+});

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

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

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

@@ -0,0 +1,101 @@
+import { addMultipleOccurencyReducer } from './addMultipleOccurency';
+const state = {
+    options: {
+        2: [true],
+        3: [false],
+        4: [true],
+    },
+    variables: {
+        2: [''],
+        3: [''],
+    },
+};
+describe('addMultipleOccurencyReducer test suit', () => {
+    it('Throws an error if optionRelations or optionsReferences are undefined', () => {
+        expect(() => {
+            addMultipleOccurencyReducer(state, {
+                id: 3,
+                optionRelations: undefined,
+                optionsReferences: 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 optionsReferences = {
+            '2': {
+                meta: {
+                    id: 2,
+                    type: 'static',
+                    label: 'Multiple question',
+                    step: '*',
+                    tags: [],
+                    defaultRadio: 4,
+                    multiple: {
+                        enabled: true,
+                    },
+                    validator: {},
+                },
+                options: [3, 4],
+                variables: [2, 3],
+            },
+            '3': {
+                meta: {
+                    id: 3,
+                    type: 'radio',
+                    label: 'Option 1',
+                    step: '*',
+                    tags: [],
+                    defaultRadio: 0,
+                    validator: {},
+                },
+                options: [],
+                variables: [],
+            },
+            '4': {
+                meta: {
+                    id: 4,
+                    type: 'radio',
+                    label: 'Option 2',
+                    step: '*',
+                    tags: [],
+                    defaultRadio: 0,
+                    validator: {},
+                },
+                options: [],
+                variables: [],
+            },
+        };
+        const reducerResult = addMultipleOccurencyReducer(state, {
+            id: 2,
+            optionRelations,
+            optionsReferences,
+            type: 'ADD_MULTIPLE_OCCURENCY',
+        });
+        expect(reducerResult).toStrictEqual({
+            options: Object.assign(Object.assign({}, state.options), { 2: [true, true], 3: [false, false], 4: [true, false] }),
+            variables: {
+                2: ['', ''],
+                3: ['', ''],
+            },
+        });
+    });
+});

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

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

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

@@ -0,0 +1,56 @@
+import { deleteMultipleOccurencyReducer } from './deleteMultipleOccurency';
+const state = {
+    options: {
+        2: [true, true, true],
+        3: [false, true, true],
+        4: [true, true, false],
+    },
+    variables: {
+        2: ['21', '22', '23'],
+        3: ['31', '32', '33'],
+    },
+};
+describe('deleteMultipleOccurencyReducer test suit', () => {
+    it('Throws an error if optionRelations 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('Deletes 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({
+            options: Object.assign(Object.assign({}, state.options), { 2: [true, true], 3: [false, true], 4: [true, false] }),
+            variables: {
+                2: ['21', '23'],
+                3: ['31', '33'],
+            },
+        });
+    });
+});

package/dist/redux/reducers/inputs.test.d.ts

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