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

package/dist/redux/actions/library.d.ts

@@ -1,33 +1,36 @@
 import * as app from "./app";
 export declare const actionsLibrary: {
-    setUserEmail: (email: string, disableRedirect?: boolean, inBackground?: boolean) => import("../..").ActionsType.User.setUserEmail;
+    setUserEmail: (email: string, disableRedirect?: boolean | undefined, inBackground?: boolean | undefined) => import("../..").ActionsType.User.setUserEmail;
     setUserEmailSucceeded: () => import("../..").ActionsType.User.setUserEmailSucceeded;
     fetchModelPrerequisitesAction: (permalink: string, prefix?: string) => import("../..").ActionsType.Sagas.Model.fetchModelPrerequisites;
     fetchModelAction: (permalink: string, prefix: string | undefined, uniqid: string | undefined, uniqidParam: string | undefined, queryParams: URLSearchParams, pathReader: import("../..").PathReader, urlParams: URLSearchParams, clientConfigReturnValue: {
         appStates: string[];
         enableShadowInstance: boolean;
     }, wizardConfig: import("../..").WizardConfigResponse) => import("../..").ActionsType.Sagas.Model.fetchModel;
-    saveDataAction: (redirect?: boolean, confirmAnswer?: boolean, redirectFallback?: string, redirectOverride?: string, additionalProperties?: Record<string, string | number>) => import("../..").ActionsType.Sagas.Data.saveData;
+    saveDataAction: (redirect?: boolean, confirmAnswer?: boolean | undefined, redirectFallback?: string | undefined, redirectOverride?: string | undefined, additionalProperties?: Record<string, string | number> | undefined) => import("../..").ActionsType.Sagas.Data.saveData;
     initUserAction: (user: Omit<import("../..").StateType.User, "status">) => import("../..").ActionsType.User.initUser;
-    setUserStatusAction: (status: "authenticated" | "unauthenticated" | "inprogress" | "failed") => import("../..").ActionsType.User.setUserStatus;
+    setUserStatusAction: (status: "failed" | "authenticated" | "unauthenticated" | "inprogress") => import("../..").ActionsType.User.setUserStatus;
     setUserValidTokenAction: (validToken: boolean) => import("../..").ActionsType.User.setUserValidToken;
     enableSmartscriptAction: () => import("../..").ActionsType.SmartScript.enableSmartScript;
-    initDataSmartscriptAction: (data: import("../..").StateType.SmartScript["data"]) => import("../..").ActionsType.SmartScript.initDataSmartscript;
+    initDataSmartscriptAction: (data: object | undefined) => import("../..").ActionsType.SmartScript.initDataSmartscript;
     callInitDataSmartscriptAction: () => import("../..").ActionsType.SmartScript.requestinitDataSmartscript;
-    initSmartscriptTriggersAction: (triggers: import("../..").StateType.SmartScript["triggers"]) => import("../..").ActionsType.SmartScript.initSmartscriptTriggers;
+    initSmartscriptTriggersAction: (triggers: {
+        options: number[];
+        variables: number[];
+    }) => import("../..").ActionsType.SmartScript.initSmartscriptTriggers;
     updateSmartscriptOptionHiddenAction: (id: number, index: number, hide: boolean) => import("../..").ActionsType.SmartScript.updateSmartscriptOptionHidden;
     updateSmartscriptVariableHiddenAction: (id: number, index: number, hide: boolean) => import("../..").ActionsType.SmartScript.updateSmartscriptVariableHidden;
     initReferencesAction: (references: import("../..").StateType.References) => import("../..").ActionsType.References.initReferences;
-    updateVariableMetaAction: (id: number, meta: import("../..").ActionsType.References.updateVariableMeta["meta"], index?: number) => import("../..").ActionsType.References.updateVariableMeta;
-    updateOptionMetaAction: (id: number, meta: import("../..").ActionsType.References.updateOptionMeta["meta"]) => import("../..").ActionsType.References.updateOptionMeta;
-    setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string) => import("../..").ActionsType.References.setDisabledVariable;
+    updateVariableMetaAction: (id: number, meta: import("../..").ActionsType.References.VariableUpdatableMeta, index?: number | undefined) => import("../..").ActionsType.References.updateVariableMeta;
+    updateOptionMetaAction: (id: number, meta: import("../..").ActionsType.References.OptionUpdatableMeta) => import("../..").ActionsType.References.updateOptionMeta;
+    setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string | undefined) => import("../..").ActionsType.References.setDisabledVariable;
     initMandatoryOptionAction: (id: number, value: boolean[]) => import("../..").ActionsType.Mandatories.initMandatoryOption;
     initMandatoryVariableAction: (id: number, value: boolean[]) => import("../..").ActionsType.Mandatories.initMandatoryVariable;
     setMandatoryIgnoreAction: (value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryIgnore;
     setMandatorySectionAction: (id: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatorySection;
     setMandatoryOptionAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryOption;
     setMandatoryVariableAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryVariable;
-    initInputsAction: (inputs: import("../..").StateType.Inputs, references?: import("../..").StateType.References) => import("../..").ActionsType.Inputs.initInputs;
+    initInputsAction: (inputs: import("../..").StateType.Inputs, references?: import("../..").StateType.References | undefined) => import("../..").ActionsType.Inputs.initInputs;
     initOptionAction: (id: number, values: boolean[]) => import("../..").ActionsType.Inputs.initOption;
     updateOptionAction: (id: number, value: boolean, index: number) => import("../..").ActionsType.Inputs.updateOptionInput;
     initVariableAction: (id: number, values: (string | number)[]) => import("../..").ActionsType.Inputs.initVariable;
@@ -43,26 +46,29 @@ export declare const actionsLibrary: {
     updateOptionValidatorConditionsAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Conditions.updateOptionValidatorCondition;
     updateVariableValidatorConditionsAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Conditions.updateVariableValidatorCondition;
     initMetaAction: (meta: Omit<import("../..").StateType.App.Meta, "fetchStatus">) => import("../..").ActionsType.App.initMeta;
-    setModelUuidAction: (modelUuid: import("../..").StateType.App.Meta["modelUuid"]) => import("../..").ActionsType.App.setModelUuid;
+    setModelUuidAction: (modelUuid: string | undefined) => import("../..").ActionsType.App.setModelUuid;
     fetchModelSucceededAction: () => import("../..").ActionsType.App.fetchModelSucceeded;
     fetchModelNonBlockingAction: () => import("../..").ActionsType.App.fetchModelNonBlocking;
-    fetchModelUnhealthyAction: (report: import("../..").StateType.App.Meta["report"]) => import("../..").ActionsType.App.fetchModelUnhealthy;
+    fetchModelUnhealthyAction: (report: {
+        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
+        raw: string;
+    } | undefined) => import("../..").ActionsType.App.fetchModelUnhealthy;
     fetchModelUserLockedAction: () => import("../..").ActionsType.App.fetchModelUserLocked;
     fetchModelFailedAction: () => import("../..").ActionsType.App.fetchModelFailed;
     setDataStatus: (dataStatus: "saved" | "unsaved" | "saving" | "failed") => import("../..").ActionsType.App.setDataStatus;
-    setFetchStatus: (fetchStatus: "waiting" | "succeeded" | "failed" | "unhealthy" | "userLocked") => import("../..").ActionsType.App.setFetchStatus;
+    setFetchStatus: (fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked") => import("../..").ActionsType.App.setFetchStatus;
     initInstanceAction: (instance: import("../..").StateType.App.Instance) => import("../..").ActionsType.App.initInstance;
     updateInstanceAction: (instance: Partial<import("../..").StateType.App.Instance>) => import("../..").ActionsType.App.updateInstance;
     updateInstancePaidAction: (isPaid: boolean) => import("../..").ActionsType.App.updateInstancePaid;
     initPaginationAction: (pagination: app.initPaginationActionPropsType) => import("../..").ActionsType.App.initPagination;
-    updateAvailableAppStatesAction: (availableAppStates: import("../..").StateType.App.Pagination["availableAppStates"], ingorePluginAppStateReset?: boolean) => import("../..").ActionsType.App.updateAvailableAppStates;
+    updateAvailableAppStatesAction: (availableAppStates: string[], ingorePluginAppStateReset?: boolean) => import("../..").ActionsType.App.updateAvailableAppStates;
     goPageAction: (page: number, pushHistory?: boolean) => import("../..").ActionsType.App.goPage;
     goNextPageAction: () => import("../..").ActionsType.App.goNextPage;
     goPreviousPageAction: () => import("../..").ActionsType.App.goPreviousPage;
     updateCurrentAppStateAction: (currentAppState: string) => import("../..").ActionsType.App.updateCurrentAppState;
     updateAvailableSectionsAction: (availableSections: number[]) => import("../..").ActionsType.App.updateAvailableSections;
     updateCurrentSectionIdAction: (currentSectionId: number) => import("../..").ActionsType.App.updateCurrentSectionId;
-    initCustomizationMetaAction: (meta: Exclude<import("@legalplace/models-v3-types").ModelV3["customization"]["meta"], undefined>) => import("../..").ActionsType.App.initCustomizationMeta;
-    initCustomizationAutoDefaultAction: (disableAutoDefault: import("../..").StateType.App.Customization["disableAutoDefault"]) => import("../..").ActionsType.App.initCustomizationAutoDefault;
+    initCustomizationMetaAction: (meta: import("@legalplace/models-v3-types").CustomizationMetaDefault) => import("../..").ActionsType.App.initCustomizationMeta;
+    initCustomizationAutoDefaultAction: (disableAutoDefault: boolean | undefined) => import("../..").ActionsType.App.initCustomizationAutoDefault;
     resetStateAction: () => import("../..").ActionsType.App.resetState;
 };

package/dist/redux/actions/references.d.ts

@@ -1,6 +1,6 @@
 import type { StateType } from "../../types/State.type";
 import type { ActionsType } from "../../types/Actions.type";
 export declare const initReferencesAction: (references: StateType.References) => ActionsType.References.initReferences;
-export declare const updateVariableMetaAction: (id: number, meta: ActionsType.References.updateVariableMeta["meta"], index?: number) => ActionsType.References.updateVariableMeta;
+export declare const updateVariableMetaAction: (id: number, meta: ActionsType.References.updateVariableMeta["meta"], index?: number | undefined) => ActionsType.References.updateVariableMeta;
 export declare const updateOptionMetaAction: (id: number, meta: ActionsType.References.updateOptionMeta["meta"]) => ActionsType.References.updateOptionMeta;
-export declare const setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string) => ActionsType.References.setDisabledVariable;
+export declare const setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string | undefined) => ActionsType.References.setDisabledVariable;

package/dist/redux/actions/references.test.d.ts

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

package/dist/redux/actions/references.test.js

@@ -0,0 +1,43 @@
+import { initReferencesAction } from './references';
+describe('References actions test suit', () => {
+    it('initReferences Action', () => {
+        const _obj = {
+            options: {},
+            variables: {},
+            relations: {
+                options: {},
+                variables: {},
+                sections: {},
+            },
+            conditions: {
+                options: {},
+                variables: {},
+                prefillers: {},
+                validators: {
+                    options: {},
+                    variables: {},
+                },
+                sections: {},
+                documents: {},
+            },
+            sections: {
+                main: {
+                    '1': {
+                        id: 1,
+                        label: 'Some label',
+                        options: [],
+                    },
+                },
+            },
+            documents: {},
+            defaults: {},
+            outputs: {},
+            evaluations: {},
+            boxes: {},
+            optionTags: {},
+            variableTags: {}
+        };
+        const action = initReferencesAction(_obj);
+        expect(action).toEqual(Object.assign({ type: 'INIT_REFERENCES' }, _obj));
+    });
+});

package/dist/redux/actions/sagas/data.d.ts

@@ -1,2 +1,2 @@
 import type { ActionsType } from "../../../types/Actions.type";
-export declare const saveDataAction: (redirect?: boolean, confirmAnswer?: boolean, redirectFallback?: string, redirectOverride?: string, additionalProperties?: Record<string, string | number>) => ActionsType.Sagas.Data.saveData;
+export declare const saveDataAction: (redirect?: boolean, confirmAnswer?: boolean | undefined, redirectFallback?: string | undefined, redirectOverride?: string | undefined, additionalProperties?: Record<string, string | number> | undefined) => ActionsType.Sagas.Data.saveData;

package/dist/redux/actions/sagas/data.test.d.ts

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

package/dist/redux/actions/sagas/data.test.js

@@ -0,0 +1,11 @@
+import { saveDataAction } from './data';
+it('Returns saveData action properkt', () => {
+    expect(saveDataAction()).toStrictEqual({
+        confirmAnswer: undefined,
+        additionalProperties: undefined,
+        type: 'SAVE_DATA',
+        redirect: false,
+        redirectFallback: undefined,
+        redirectOverride: undefined,
+    });
+});

package/dist/redux/actions/sagas/model.test.d.ts

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

package/dist/redux/actions/sagas/model.test.js

@@ -0,0 +1,11 @@
+import { fetchModelPrerequisitesAction } from './model';
+describe('Saga model actions test suit', () => {
+    it('fetchModelPrerequisites Action', () => {
+        const action = fetchModelPrerequisitesAction('test-debug');
+        return expect(action).toStrictEqual({
+            type: 'FETCH_MODEL_PREREQUISITES',
+            permalink: 'test-debug',
+            prefix: '',
+        });
+    });
+});

package/dist/redux/actions/sagas/user.d.ts

@@ -1,3 +1,3 @@
 import type { ActionsType } from "../../../types/Actions.type";
-export declare const setUserEmail: (email: string, disableRedirect?: boolean, inBackground?: boolean) => ActionsType.User.setUserEmail;
+export declare const setUserEmail: (email: string, disableRedirect?: boolean | undefined, inBackground?: boolean | undefined) => ActionsType.User.setUserEmail;
 export declare const setUserEmailSucceeded: () => ActionsType.User.setUserEmailSucceeded;

package/dist/redux/actions/user.test.d.ts

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

package/dist/redux/actions/user.test.js

@@ -0,0 +1,16 @@
+import { initUserAction } from './user';
+describe('User actions test suit', () => {
+    it('initUser Action', () => {
+        const action = initUserAction({
+            level: 'ADMIN',
+            email: 'doe@legalplace.fr',
+            displayName: 'John Doe',
+        });
+        return expect(action).toStrictEqual({
+            type: 'INIT_USER',
+            level: 'ADMIN',
+            email: 'doe@legalplace.fr',
+            displayName: 'John Doe',
+        });
+    });
+});

package/dist/redux/listeners/subscriber.d.ts

@@ -1,5 +1,5 @@
 import type { Store, Dispatch, AnyAction } from "redux";
 import type { StateType } from "../../types/State.type";
-export type StoreListener = (previousState: StateType, currentState: StateType, dispatch: Dispatch<AnyAction>) => void;
+export declare type StoreListener = (previousState: StateType, currentState: StateType, dispatch: Dispatch<AnyAction>) => void;
 declare const subscribeListeners: (store: Store, listenersToSubscribe?: StoreListener[]) => void;
 export default subscribeListeners;

package/dist/redux/listeners/subscriber.test.d.ts

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

package/dist/redux/listeners/subscriber.test.js

@@ -0,0 +1,31 @@
+import { combineReducers, createStore } from 'redux';
+import subscribeListeners from './subscriber';
+describe('Store subscriber test suit', () => {
+    it('Subscribes a listener correctly to the store', () => {
+        const initialState = 0;
+        const goNextPageReducer = (state = initialState, action) => {
+            let page = state;
+            if (action.type === 'GO_NEXT_PAGE')
+                page += 1;
+            return page;
+        };
+        const store = createStore(combineReducers({ page: goNextPageReducer }));
+        const result = {
+            currentPage: 0,
+            previousPage: 0,
+        };
+        const listener = (previousState, currentState, dispatch) => {
+            result.currentPage = currentState.page;
+            if (typeof dispatch === 'function')
+                result.previousPage = previousState ? previousState.page : 0;
+        };
+        subscribeListeners(store, [listener]);
+        store.dispatch({ type: 'GO_NEXT_PAGE' });
+        store.dispatch({ type: 'GO_NEXT_PAGE' });
+        store.dispatch({ type: 'GO_NEXT_PAGE' });
+        expect(result).toStrictEqual({
+            currentPage: 3,
+            previousPage: 2,
+        });
+    });
+});

package/dist/redux/middlewares/conditionsWatcherMiddleware.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.Conditions.initConditions;
+export declare type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Conditions.initConditions;
 declare const conditionsWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default conditionsWatcherMiddleware;

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

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

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

@@ -0,0 +1,330 @@
+import conditionsWatcherMiddleware from "./conditionsWatcherMiddleware";
+import { addMultipleOccurencyAction, deleteMultipleOccurencyAction, updateOptionAction, updateVariableAction, } from "../actions/inputs";
+import { initConditionsAction } from "../actions/conditions";
+import { selectorsMiddleware } from "../selectors/selectors";
+const mockInputs = {
+    variables: {
+        1: ["Hello"],
+        2: [],
+        3: [],
+    },
+    options: {
+        1: [true],
+        2: [true, true],
+        3: [true, false],
+        4: [false, true],
+        7: [true, true],
+        8: [true, true],
+    },
+};
+const mpi = {
+    dispatch: jest.fn(),
+    getState: () => ({
+        app: {
+            instance: {
+                dataStatus: "saved",
+            },
+        },
+        inputs: mockInputs,
+    }),
+};
+const next = jest.fn();
+const initialConditions = {
+    options: {},
+    variables: {},
+    documents: {},
+    sections: {},
+    prefillers: {},
+    validators: {
+        options: {},
+        variables: {},
+    },
+};
+const mockOptionsRelations = {
+    2: {
+        options: [],
+        variables: [],
+        sections: {},
+        documents: [],
+        prefillers: [],
+        validators: {
+            options: [],
+            variables: [],
+        },
+        parents: [],
+        children: {
+            options: [3, 4],
+            variables: [2, 3],
+        },
+        dependants: [7, 8],
+    },
+};
+jest.mock("../selectors/inputs", () => ({
+    __esModule: true,
+    selectOptionInput: (id) => mockInputs.options[id],
+    selectOptionInputByIndex: (id, index) => mockInputs.options[id][index],
+    selectVariableInput: (id) => mockInputs.variables[id],
+    selectVariableInputByIndex: (id, index) => mockInputs.variables[id][index],
+}));
+jest.mock("../../libs/ConditionsRunner", () => {
+    class ConditionsRunnerMock {
+        constructor(dispatch) {
+            this.dispatch = dispatch;
+        }
+        executeHooks(...args) {
+            this.dispatch({
+                type: "EXEC_HOOKS_MOCK",
+                arguments: args,
+            });
+        }
+    }
+    return {
+        __esModule: true,
+        ConditionsRunner: ConditionsRunnerMock,
+    };
+});
+const mockOptionsConditions = {};
+const mockVariablesConditions = {};
+jest.mock("../selectors/references", () => ({
+    __esModule: true,
+    selectOptionRelations: (id) => mockOptionsRelations[id],
+    selectOptionConditionsObject: (id) => mockOptionsConditions[id],
+    selectVariableConditionsObject: (id) => mockVariablesConditions[id],
+}));
+describe("Conditions Watcher Middleware Test suit", () => {
+    beforeEach(() => {
+        selectorsMiddleware(mpi)(next)({ type: "@INIT" });
+        jest.clearAllMocks();
+    });
+    it("Completes INIT_CONDITIONS action correctly", () => {
+        conditionsWatcherMiddleware(mpi)(next)(initConditionsAction(initialConditions));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual(Object.assign({ type: "INIT_CONDITIONS" }, initialConditions));
+        expect(mpi.dispatch.mock.calls.length).toBe(12);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 1, 0],
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 0],
+        });
+        expect(mpi.dispatch.mock.calls[2][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 1],
+        });
+        expect(mpi.dispatch.mock.calls[3][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 0],
+        });
+        expect(mpi.dispatch.mock.calls[4][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 1],
+        });
+        expect(mpi.dispatch.mock.calls[5][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 0],
+        });
+        expect(mpi.dispatch.mock.calls[6][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 1],
+        });
+        expect(mpi.dispatch.mock.calls[7][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 0],
+        });
+        expect(mpi.dispatch.mock.calls[8][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 1],
+        });
+        expect(mpi.dispatch.mock.calls[9][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 0],
+        });
+        expect(mpi.dispatch.mock.calls[10][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 1],
+        });
+        expect(mpi.dispatch.mock.calls[11][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 1, 0],
+        });
+    });
+    it("Completes UPDATE_OPTION_INPUT action correctly", () => {
+        conditionsWatcherMiddleware(mpi)(next)(updateOptionAction(3, false, 0));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: "UPDATE_OPTION_INPUT",
+            id: 3,
+            index: 0,
+            value: false,
+        });
+        expect(mpi.dispatch.mock.calls.length).toBe(2);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: "SET_DATA_STATUS",
+            dataStatus: "unsaved",
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 0],
+        });
+    });
+    it("Completes UPDATE_VARIABLE_INPUT action correctly", () => {
+        conditionsWatcherMiddleware(mpi)(next)(updateVariableAction(1, "Hey", 0));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: "UPDATE_VARIABLE_INPUT",
+            id: 1,
+            index: 0,
+            value: "Hey",
+        });
+        expect(mpi.dispatch.mock.calls.length).toBe(2);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: "SET_DATA_STATUS",
+            dataStatus: "unsaved",
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 1, 0],
+        });
+    });
+    it("Completes ADD_MULTIPLE_OCCURENCY action correctly", () => {
+        conditionsWatcherMiddleware(mpi)(next)(addMultipleOccurencyAction(2));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: "ADD_MULTIPLE_OCCURENCY",
+            id: 2,
+        });
+        expect(mpi.dispatch.mock.calls.length).toBe(15);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: "SET_DATA_STATUS",
+            dataStatus: "unsaved",
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 0],
+        });
+        expect(mpi.dispatch.mock.calls[2][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 1],
+        });
+        expect(mpi.dispatch.mock.calls[3][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 0],
+        });
+        expect(mpi.dispatch.mock.calls[4][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 1],
+        });
+        expect(mpi.dispatch.mock.calls[5][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 0],
+        });
+        expect(mpi.dispatch.mock.calls[6][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 1],
+        });
+        expect(mpi.dispatch.mock.calls[7][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 0],
+        });
+        expect(mpi.dispatch.mock.calls[8][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 1],
+        });
+        expect(mpi.dispatch.mock.calls[9][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 0],
+        });
+        expect(mpi.dispatch.mock.calls[10][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 1],
+        });
+        expect(mpi.dispatch.mock.calls[11][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 2, 0],
+        });
+        expect(mpi.dispatch.mock.calls[12][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 2, 1],
+        });
+        expect(mpi.dispatch.mock.calls[13][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 3, 0],
+        });
+        expect(mpi.dispatch.mock.calls[14][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 3, 1],
+        });
+    });
+    it("Completes DELETE_MULTIPLE_OCCURENCY action correctly", () => {
+        conditionsWatcherMiddleware(mpi)(next)(deleteMultipleOccurencyAction(2, 1));
+        expect(next.mock.calls.length).toBe(1);
+        expect(next.mock.calls[0][0]).toStrictEqual({
+            type: "DELETE_MULTIPLE_OCCURENCY",
+            id: 2,
+            index: 1,
+        });
+        expect(mpi.dispatch.mock.calls.length).toBe(15);
+        expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+            type: "SET_DATA_STATUS",
+            dataStatus: "unsaved",
+        });
+        expect(mpi.dispatch.mock.calls[1][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 0],
+        });
+        expect(mpi.dispatch.mock.calls[2][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 2, 1],
+        });
+        expect(mpi.dispatch.mock.calls[3][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 0],
+        });
+        expect(mpi.dispatch.mock.calls[4][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 3, 1],
+        });
+        expect(mpi.dispatch.mock.calls[5][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 0],
+        });
+        expect(mpi.dispatch.mock.calls[6][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 4, 1],
+        });
+        expect(mpi.dispatch.mock.calls[7][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 0],
+        });
+        expect(mpi.dispatch.mock.calls[8][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 7, 1],
+        });
+        expect(mpi.dispatch.mock.calls[9][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 0],
+        });
+        expect(mpi.dispatch.mock.calls[10][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["options", 8, 1],
+        });
+        expect(mpi.dispatch.mock.calls[11][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 2, 0],
+        });
+        expect(mpi.dispatch.mock.calls[12][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 2, 1],
+        });
+        expect(mpi.dispatch.mock.calls[13][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 3, 0],
+        });
+        expect(mpi.dispatch.mock.calls[14][0]).toStrictEqual({
+            type: "EXEC_HOOKS_MOCK",
+            arguments: ["variables", 3, 1],
+        });
+    });
+});

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

@@ -2,6 +2,6 @@ import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
 import type { StateType } from "../../types/State.type";
 export declare const watchUpdateVariable: (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: ActionsType.Inputs.updateVariableInput | ActionsType.Conditions.updateVariableCondition) => ActionsType.Inputs.updateVariableInput | ActionsType.Conditions.updateVariableCondition;
-export type WatcherActions = ActionsType.Conditions.updateVariableCondition | ActionsType.Conditions.updateOptionCondition | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.App.fetchModelSucceeded;
+export declare type WatcherActions = ActionsType.Conditions.updateVariableCondition | ActionsType.Conditions.updateOptionCondition | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.App.fetchModelSucceeded;
 declare const evaluationsWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default evaluationsWatcherMiddleware;

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

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