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

package/dist/redux/middlewares/evaluationsWatcherMiddleware.test.js

@@ -0,0 +1,242 @@
+import evaluationsWatcherMiddleware from './evaluationsWatcherMiddleware';
+import { updateVariableAction, updateOptionAction } from '../actions/inputs';
+import { fetchModelSucceededAction } from '../actions/app';
+import { updateOptionConditionsAction, updateVariableConditionsAction, } from '../actions/conditions';
+let mockState = {
+    inputs: {
+        variables: {
+            4: [32],
+            5: [67],
+            6: [''],
+            7: [22],
+        },
+        options: {
+            10: [false],
+        },
+    },
+    references: {
+        variables: {
+            '6': {
+                id: 6,
+                label: 'A+B',
+                type: 'eval',
+                placeholderLength: 16,
+                step: '*',
+                eval: {
+                    formula: '[var:4]+[var:5]+[var:7]',
+                    decimals: 0,
+                },
+            },
+            '8': {
+                id: 8,
+                label: 'TODAY',
+                type: 'eval',
+                placeholderLength: 16,
+                step: '*',
+                eval: {
+                    formula: 'AFFICHER_DATE(TODAY())',
+                    decimals: 0,
+                },
+            },
+        },
+        relations: {
+            options: {
+                '4': {
+                    options: [7, 8],
+                    variables: [2],
+                    sections: {},
+                    documents: [],
+                    prefillers: [3],
+                    validators: {
+                        options: [],
+                        variables: [],
+                    },
+                    parents: [2],
+                    children: {
+                        options: [],
+                        variables: [],
+                    },
+                    dependants: [],
+                    radioSiblings: [3],
+                },
+                '8': {
+                    options: [],
+                    variables: [],
+                    sections: {},
+                    documents: [],
+                    prefillers: [],
+                    validators: {
+                        options: [],
+                        variables: [],
+                    },
+                    parents: [6],
+                    children: {
+                        options: [],
+                        variables: [],
+                    },
+                    dependants: [],
+                },
+                '10': {
+                    options: [],
+                    variables: [],
+                    sections: {},
+                    documents: [],
+                    prefillers: [],
+                    validators: {
+                        options: [],
+                        variables: [],
+                    },
+                    parents: [9],
+                    children: {
+                        options: [],
+                        variables: [7],
+                    },
+                    dependants: [],
+                    radioSiblings: [11],
+                },
+                '11': {
+                    options: [],
+                    variables: [],
+                    sections: {},
+                    documents: [],
+                    prefillers: [],
+                    validators: {
+                        options: [],
+                        variables: [],
+                    },
+                    parents: [9],
+                    children: {
+                        options: [],
+                        variables: [],
+                    },
+                    dependants: [],
+                    radioSiblings: [10],
+                },
+            },
+        },
+        evaluations: {
+            4: [6],
+            5: [6],
+            7: [6],
+        },
+    },
+};
+const originalState = JSON.stringify(mockState);
+const mpi = {
+    dispatch: jest.fn(),
+    getState: () => mockState,
+};
+const next = jest.fn();
+jest.mock('../selectors/references', () => ({
+    __esModule: true,
+    selectVariableReference: (id) => mockState.references.variables[id],
+    selectOptionRelations: (id) => mockState.references.relations.options[id],
+}));
+jest.mock('../../libs/EvalVariable', () => {
+    class EvalVariable {
+        constructor(ref, index) {
+            var _a;
+            if (ref.id === 8 && ((_a = ref.eval) === null || _a === void 0 ? void 0 : _a.formula) === 'AFFICHER_DATE(TODAY())')
+                this.result = '01/01/1976';
+            else if (ref.id === 6 && mockState.inputs.options[10][index] === true)
+                this.result =
+                    mockState.inputs.variables[4][index] +
+                        mockState.inputs.variables[5][index] +
+                        mockState.inputs.variables[7][index];
+            else if (ref.id === 6 && mockState.inputs.options[10][index] === false)
+                this.result =
+                    mockState.inputs.variables[4][index] +
+                        mockState.inputs.variables[5][index];
+            else
+                this.result = 'UNDEFINED RESULT PLEASE CHECK MOCK';
+        }
+    }
+    return {
+        __esModule: true,
+        EvalVariable,
+    };
+});
+describe('Prefillers Watcher Middleware Test suit', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockState = JSON.parse(originalState);
+    });
+    it('Completes FETCH_MODEL_SUCCEEDED action correctly', () => {
+        evaluationsWatcherMiddleware(mpi)(next)(fetchModelSucceededAction());
+        expect(mpi.dispatch.mock.calls.length).toBe(2);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 99,
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 8,
+            index: 0,
+            value: '01/01/1976',
+        });
+    });
+    it('Completes UPDATE_VARIABLE_INPUT action correctly', () => {
+        evaluationsWatcherMiddleware(mpi)(next)(updateVariableAction(4, 3, 0));
+        expect(mpi.dispatch.mock.calls.length).toBe(1);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 99,
+        });
+    });
+    it('Completes UPDATE_OPTION_INPUT action correctly', () => {
+        mockState.inputs.options[10][0] = true;
+        evaluationsWatcherMiddleware(mpi)(next)(updateOptionAction(10, true, 0));
+        expect(mpi.dispatch.mock.calls.length).toBe(1);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 121,
+        });
+    });
+    it('Completes UPDATE_OPTION_CONDITION action correctly', () => {
+        mockState.inputs.options[10][0] = true;
+        evaluationsWatcherMiddleware(mpi)(next)(updateOptionConditionsAction(10, 0, true));
+        expect(mpi.dispatch.mock.calls.length).toBe(1);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 121,
+        });
+    });
+    it('Completes UPDATE_OPTION_CONDITION action correctly', () => {
+        mockState.inputs.options[10][0] = false;
+        evaluationsWatcherMiddleware(mpi)(next)(updateOptionConditionsAction(10, 0, true));
+        expect(mpi.dispatch.mock.calls.length).toBe(1);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 99,
+        });
+    });
+    it('Completes UPDATE_VARIABLE_CONDITION action correctly', () => {
+        mockState.inputs.options[10][0] = true;
+        evaluationsWatcherMiddleware(mpi)(next)(updateVariableConditionsAction(7, 0, true));
+        expect(mpi.dispatch.mock.calls.length).toBe(1);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 6,
+            index: 0,
+            value: 121,
+        });
+    });
+    it('Throws an error on UPDATE_VARIABLE_INPUT action if variable is undefined', () => {
+        mockState.references.variables[6] = undefined;
+        expect(() => evaluationsWatcherMiddleware(mpi)(next)(updateVariableAction(4, 3, 0))).toThrowError('Variable 6 does not exist');
+    });
+    it('Throws an error on UPDATE_OPTION_INPUT action if variable is undefined', () => {
+        mockState.references.variables[6] = undefined;
+        expect(() => evaluationsWatcherMiddleware(mpi)(next)(updateOptionAction(10, true, 0))).toThrowError('Variable 6 does not exist');
+    });
+});

package/dist/redux/middlewares/mandatoriesWatcherMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { Dispatch, MiddlewareAPI } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Mandatories.setMandatoryOption | ActionsType.Mandatories.setMandatoryVariable;
+export declare type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Mandatories.setMandatoryOption | ActionsType.Mandatories.setMandatoryVariable;
 declare const mandatoriesWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default mandatoriesWatcherMiddleware;

package/dist/redux/middlewares/multiplesActionsMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency;
+export declare type WatcherActions = ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency;
 declare const multiplesActionsMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default multiplesActionsMiddleware;

package/dist/redux/middlewares/multiplesActionsMiddleware.test.d.ts

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

package/dist/redux/middlewares/multiplesActionsMiddleware.test.js

@@ -0,0 +1,209 @@
+import multiplesActionsMiddleware from './multiplesActionsMiddleware';
+import { addMultipleOccurencyAction, deleteMultipleOccurencyAction, } from '../actions/inputs';
+const mpi = {
+    dispatch: jest.fn(),
+    getState: () => ({
+        conditions: {
+            prefillers: {
+                '3': [[false, false, false]],
+            },
+        },
+    }),
+};
+const next = jest.fn();
+const mockVariablesReferences = {
+    3: {
+        id: 3,
+        label: 'Variable',
+        type: 'textarea',
+        step: '*',
+        prefillings: [
+            {
+                value: 'Option 4 selected',
+                conditions: {
+                    selected: [
+                        {
+                            var: 'o.4',
+                        },
+                    ],
+                },
+            },
+            {
+                value: 'Option 3 selected',
+                conditions: {
+                    selected: [
+                        {
+                            var: 'o.3',
+                        },
+                    ],
+                },
+            },
+            {
+                value: 'Variable 1 = Hello',
+                conditions: {
+                    contains: [
+                        {
+                            var: 'v.1',
+                        },
+                        'Hello',
+                    ],
+                },
+            },
+        ],
+    },
+};
+const mockOptionsRelations = {
+    2: {
+        options: [],
+        variables: [],
+        sections: {},
+        documents: [],
+        prefillers: [],
+        validators: {
+            options: [],
+            variables: [],
+        },
+        parents: [],
+        children: {
+            options: [3, 4],
+            variables: [2, 3],
+        },
+        dependants: [7, 8],
+    },
+};
+const mockOptionsReferences = {
+    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: [],
+    },
+    7: {
+        meta: {
+            id: 4,
+            type: 'hidden',
+            label: 'Option 2',
+            step: '*',
+            tags: [],
+            defaultRadio: 0,
+            validator: {},
+        },
+        options: [],
+        variables: [],
+    },
+    8: {
+        meta: {
+            id: 4,
+            type: 'hidden',
+            label: 'Option 2',
+            step: '*',
+            tags: [],
+            defaultRadio: 0,
+            validator: {},
+        },
+        options: [],
+        variables: [],
+    },
+};
+jest.mock('../selectors/references', () => ({
+    __esModule: true,
+    selectVariableReference: (id) => mockVariablesReferences[id],
+    selectOptionRelations: (id) => mockOptionsRelations[id],
+    selectOptionReference: (id) => mockOptionsReferences[id],
+}));
+describe('Prefillers Watcher Middleware Test suit', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('Completes ADD_MULTIPLE_OCCURENCY action correctly', () => {
+        multiplesActionsMiddleware(mpi)(next)(addMultipleOccurencyAction(2));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: 'ADD_MULTIPLE_OCCURENCY',
+            id: 2,
+            optionRelations: mockOptionsRelations[2],
+            optionsReferences: mockOptionsReferences,
+            prefillersVariables: {
+                '3': [
+                    {
+                        value: 'Option 4 selected',
+                        conditions: {
+                            selected: [
+                                {
+                                    var: 'o.4',
+                                },
+                            ],
+                        },
+                    },
+                    {
+                        value: 'Option 3 selected',
+                        conditions: {
+                            selected: [
+                                {
+                                    var: 'o.3',
+                                },
+                            ],
+                        },
+                    },
+                    {
+                        value: 'Variable 1 = Hello',
+                        conditions: {
+                            contains: [
+                                {
+                                    var: 'v.1',
+                                },
+                                'Hello',
+                            ],
+                        },
+                    },
+                ],
+            },
+        });
+    });
+    it('Completes DELETE_MULTIPLE_OCCURENCY action correctly', () => {
+        multiplesActionsMiddleware(mpi)(next)(deleteMultipleOccurencyAction(2, 3));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: 'DELETE_MULTIPLE_OCCURENCY',
+            id: 2,
+            index: 3,
+            optionRelations: mockOptionsRelations[2],
+        });
+    });
+});

package/dist/redux/middlewares/paginationWatcherMiddleware.d.ts

@@ -1,6 +1,6 @@
 import type { LocationChangeAction } from "connected-react-router";
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.Conditions.updateSectionCondition | LocationChangeAction;
-declare const paginationWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => any;
+export declare type WatcherActions = ActionsType.Conditions.updateSectionCondition | LocationChangeAction;
+declare const paginationWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default paginationWatcherMiddleware;

package/dist/redux/middlewares/pluginsHookMiddleware.d.ts

@@ -1,2 +1,3 @@
-declare const pluginsHookMiddleware: any;
+import type { MiddlewareAPI, Dispatch, Action } from "redux";
+declare const pluginsHookMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: Action) => Action<any>;
 export default pluginsHookMiddleware;

package/dist/redux/middlewares/pluginsHookMiddleware.js

@@ -1,4 +1,10 @@
+import { RunActionAnchor, RunOverrideActionAnchor } from "../../PluginLoader";
 const pluginsHookMiddleware = (mpi) => (next) => (action) => {
-    return next(action);
+    const previousState = mpi.getState();
+    const overridenAction = RunOverrideActionAnchor(action);
+    const nextResult = next(overridenAction);
+    const nextState = mpi.getState();
+    RunActionAnchor(action.type, previousState, nextState);
+    return nextResult;
 };
 export default pluginsHookMiddleware;

package/dist/redux/middlewares/prefillerWatcherMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.Conditions.updatePrefillerCondition;
+export declare type WatcherActions = ActionsType.Conditions.updatePrefillerCondition;
 declare const prefillerWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | ActionsType.Conditions.updatePrefillerCondition;
 export default prefillerWatcherMiddleware;

package/dist/redux/middlewares/prefillerWatcherMiddleware.test.d.ts

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

package/dist/redux/middlewares/prefillerWatcherMiddleware.test.js

@@ -0,0 +1,84 @@
+import prefillerWatcherMiddleware from './prefillerWatcherMiddleware';
+import { updatePrefillersConditionsAction } from '../actions/conditions';
+const mpi = {
+    dispatch: jest.fn(),
+    getState: jest.fn(),
+};
+const next = jest.fn();
+const mockVariablesInputs = {
+    3: ['Option 4 selected', 'Random text'],
+};
+const mockVariablesReferences = {
+    3: {
+        id: 3,
+        label: 'Variable',
+        type: 'textarea',
+        step: '*',
+        prefillings: [
+            {
+                value: 'Option 4 selected',
+                conditions: {
+                    selected: [
+                        {
+                            var: 'o.4',
+                        },
+                    ],
+                },
+            },
+            {
+                value: 'Option 3 selected',
+                conditions: {
+                    selected: [
+                        {
+                            var: 'o.3',
+                        },
+                    ],
+                },
+            },
+            {
+                value: 'Variable 1 = Hello',
+                conditions: {
+                    contains: [
+                        {
+                            var: 'v.1',
+                        },
+                        'Hello',
+                    ],
+                },
+            },
+        ],
+    },
+};
+jest.mock('../selectors/inputs', () => ({
+    __esModule: true,
+    selectVariableInputByIndex: (id, index) => mockVariablesInputs[id][index],
+}));
+jest.mock('../selectors/references', () => ({
+    __esModule: true,
+    selectVariableReference: (id) => mockVariablesReferences[id],
+}));
+describe('Prefillers Watcher Middleware Test suit', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('Updates variables properly if prefillers conditions changed', () => {
+        prefillerWatcherMiddleware(mpi)(next)(updatePrefillersConditionsAction(3, 0, [false, false, true]));
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: 'UPDATE_VARIABLE_INPUT',
+            id: 3,
+            value: 'Variable 1 = Hello',
+            index: 0,
+        });
+    });
+    it('Should throw an error if variable does not exist', () => {
+        expect(() => prefillerWatcherMiddleware(mpi)(next)(updatePrefillersConditionsAction(13243, 0, [true, false, false]))).toThrowError('Variable 13243 does not exist');
+    });
+    it('Should not send update variable value if value is already equal to the prefiller', () => {
+        prefillerWatcherMiddleware(mpi)(next)(updatePrefillersConditionsAction(3, 0, [true, false, false]));
+        expect(mpi.dispatch.mock.calls.length).toEqual(0);
+    });
+    it('Should not send update variable value if value has been changed by user', () => {
+        prefillerWatcherMiddleware(mpi)(next)(updatePrefillersConditionsAction(3, 1, [true, true, true]));
+        expect(mpi.dispatch.mock.calls.length).toEqual(0);
+    });
+});

package/dist/redux/middlewares/smartscriptMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.SmartScript.enableSmartScript | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput;
+export declare type WatcherActions = ActionsType.SmartScript.enableSmartScript | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput;
 declare const smartscriptMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default smartscriptMiddleware;

package/dist/redux/middlewares/smartscriptMiddleware.js

@@ -89,13 +89,13 @@ const watchUpdateOptionInput = (mpi, next, action) => __awaiter(void 0, void 0,
     }
 });
 const watchUpdateVariableInput = (mpi, next, action) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _b;
     next(action);
     const state = mpi.getState();
     const { id } = action;
     if (state.smartscript.triggers.variables.includes(id)) {
         try {
-            const actions = yield ((_a = iframe === null || iframe === void 0 ? void 0 : iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.triggerListeners("variable", id, cloneDeep(state.inputs)));
+            const actions = yield ((_b = iframe === null || iframe === void 0 ? void 0 : iframe.contentWindow) === null || _b === void 0 ? void 0 : _b.triggerListeners("variable", id, cloneDeep(state.inputs)));
             if (Array.isArray(actions)) {
                 actions.forEach((_action) => {
                     mpi.dispatch(_action);

package/dist/redux/middlewares/thirdpartyScriptsMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export type WatcherActions = ActionsType.App.fetchModelSucceeded;
+export declare type WatcherActions = ActionsType.App.fetchModelSucceeded;
 declare const thirdPartyScriptsMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | ActionsType.App.fetchModelSucceeded;
 export default thirdPartyScriptsMiddleware;

package/dist/redux/reducers/app/instance.test.d.ts

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