@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/middlewares/mandatoriesWatcherMiddleware.js

@@ -0,0 +1,220 @@
+import { UPDATE_OPTION_INPUT, UPDATE_VARIABLE_INPUT, ADD_MULTIPLE_OCCURENCY, DELETE_MULTIPLE_OCCURENCY, } from '../constants/inputs';
+import { selectVariableInputByIndex, selectOptionInputByIndex, selectOptionInput, } from '../selectors/inputs';
+import { SET_MANDATORY_OPTION, SET_MANDATORY_VARIABLE, } from '../constants/mandatories';
+import { selectOptionRelations, selectOptionReference, selectSectionReference, selectVariableRelations, selectAllSectionsReferences, selectRadioSiblings, } from '../selectors/references';
+import { selectMandatoryOption, selectMandatoryVariable, } from '../selectors/mandatories';
+import { setMandatoryOptionAction, setMandatorySectionAction, setMandatoryVariableAction, } from '../actions/mandatories';
+import { UPDATE_OPTION_CONDITION, UPDATE_VARIABLE_CONDITION, UPDATE_SECTION_CONDITION, } from '../constants/conditions';
+import { selectOptionConditionValue, selectVariableConditionValue, selectIsOptionDisplayed, selectIsVariableDisplayed, } from '../selectors/conditions';
+import { FETCH_MODEL_SUCCEEDED } from '../constants/app';
+const validateSectionMandatory = (mpi, sectionId) => {
+    const parentSection = selectSectionReference(sectionId);
+    let childOptions = [...parentSection.options];
+    let childVariables = [];
+    parentSection.options.forEach((childOptionId) => {
+        let childOptionSelectedId;
+        let otherOptions = [];
+        const childReferenceOption = selectOptionReference(childOptionId);
+        childReferenceOption.options.forEach((subChildOptionId) => {
+            const optionReference = selectOptionReference(subChildOptionId);
+            const { type: optionType } = optionReference.meta;
+            if (['radio'].includes(optionType)) {
+                if (selectOptionInput(subChildOptionId).every((v) => v === true))
+                    childOptionSelectedId = subChildOptionId;
+            }
+            else {
+                otherOptions = [...otherOptions, subChildOptionId];
+                childVariables = [
+                    ...childVariables,
+                    ...selectOptionRelations(childOptionId).children.variables,
+                ];
+            }
+        });
+        if (childOptionSelectedId) {
+            const childRelations = selectOptionRelations(childOptionSelectedId);
+            childOptions = [
+                ...childOptions,
+                childOptionSelectedId,
+                ...childRelations.children.options,
+                ...otherOptions,
+            ];
+            childVariables = [
+                ...childVariables,
+                ...childRelations.children.variables,
+            ];
+        }
+        else {
+            const childRelations = selectOptionRelations(childOptionId);
+            childOptions = [...childOptions, ...childRelations.children.options];
+            childVariables = [
+                ...childVariables,
+                ...childRelations.children.variables,
+            ];
+        }
+    });
+    childVariables = childVariables.filter((item, pos, self) => {
+        return self.indexOf(item) === pos;
+    });
+    childOptions = childOptions.filter((childId) => Object.prototype.hasOwnProperty.call(mpi.getState().mandatories.options, childId));
+    childVariables = childVariables.filter((childId) => Object.prototype.hasOwnProperty.call(mpi.getState().mandatories.variables, childId));
+    const sectionOptionsValues = childOptions.reduce((previousValue, currentOptionId) => {
+        const currentOptionValue = selectMandatoryOption(currentOptionId)
+            .map((value, index) => {
+            const displayed = selectIsOptionDisplayed(currentOptionId, index);
+            let result = !displayed || (displayed && value);
+            if (result === false) {
+                const siblings = selectRadioSiblings(currentOptionId);
+                if (siblings && siblings.length) {
+                    siblings.forEach((siblingOptionId) => {
+                        if (result === false) {
+                            if (childOptions.includes(siblingOptionId)) {
+                                const displayedSibling = selectIsOptionDisplayed(currentOptionId, index);
+                                const selectedSibling = selectOptionInput(siblingOptionId)[index];
+                                result =
+                                    !displayedSibling ||
+                                        (displayedSibling &&
+                                            selectMandatoryOption(siblingOptionId)[index] &&
+                                            selectedSibling);
+                            }
+                            else if (selectOptionInput(siblingOptionId)[index]) {
+                                result = true;
+                            }
+                        }
+                    });
+                }
+            }
+            return result;
+        })
+            .every((v) => v === true);
+        return previousValue && currentOptionValue;
+    }, true);
+    const sectionVariablesValues = childVariables.reduce((previousValue, currentVariableId) => {
+        const currentVariableValue = selectMandatoryVariable(currentVariableId)
+            .map((value, index) => {
+            const displayed = selectIsVariableDisplayed(currentVariableId, index);
+            return !displayed || (displayed && value);
+        })
+            .every((v) => v === true);
+        return previousValue && currentVariableValue;
+    }, true);
+    const sectionValue = sectionOptionsValues && sectionVariablesValues;
+    if (mpi.getState().mandatories.sections[sectionId] !== sectionValue) {
+        mpi.dispatch(setMandatorySectionAction(sectionId, sectionValue));
+    }
+};
+const watchSectionMandatory = (mpi, next, action) => {
+    const { type, id } = action;
+    next(action);
+    let sectionId = id;
+    if (action.type !== UPDATE_SECTION_CONDITION) {
+        const isVariable = [SET_MANDATORY_VARIABLE].includes(type);
+        const { parents } = isVariable
+            ? selectVariableRelations(id)
+            : selectOptionRelations(id);
+        const rootParentId = parents.length > 0 ? parents[parents.length - 1] : id;
+        sectionId = Object.keys(selectAllSectionsReferences() || {})
+            .map((v) => parseInt(v, 10))
+            .find((currentSectionId) => selectSectionReference(currentSectionId).options.includes(rootParentId));
+    }
+    if (sectionId !== undefined)
+        validateSectionMandatory(mpi, sectionId);
+};
+const watchUpdateVariableInputCondition = (mpi, next, action, ignoreNext) => {
+    const { type, id, index, value } = action;
+    if (ignoreNext !== true)
+        next(action);
+    if (mpi.getState().mandatories.variables[id] === undefined)
+        return;
+    const inputValue = type === UPDATE_VARIABLE_INPUT
+        ? `${value}`.trim().length > 0
+        : `${selectVariableInputByIndex(id, index)}`.trim().length > 0;
+    const conditionValue = action.type === UPDATE_VARIABLE_CONDITION
+        ? action.value
+        : selectVariableConditionValue(id, index) !== false;
+    const mandatoryValue = !conditionValue || (conditionValue && inputValue);
+    mpi.dispatch(setMandatoryVariableAction(id, index, mandatoryValue));
+};
+const watchUpdateOptionInputCondition = (mpi, next, action, ignoreNext) => {
+    var _a;
+    const { type, id, index, value } = action;
+    if (ignoreNext !== true)
+        next(action);
+    const optionReference = selectOptionReference(id);
+    const { type: optionType } = optionReference.meta;
+    if (['radio', 'checkbox'].includes(optionType)) {
+        const inputValue = type === UPDATE_OPTION_INPUT
+            ? value
+            : selectOptionInputByIndex(id, index) === true;
+        const conditionValue = type === UPDATE_OPTION_CONDITION
+            ? value
+            : selectOptionConditionValue(id, index) !== false;
+        const mandatoryValue = !conditionValue || (conditionValue && inputValue);
+        if (optionType === 'radio') {
+            const { parents } = selectOptionRelations(id);
+            const [parentId] = parents;
+            const parentOption = selectOptionReference(parentId);
+            const siblingsMandatoryValues = (_a = parentOption === null || parentOption === void 0 ? void 0 : parentOption.options) === null || _a === void 0 ? void 0 : _a.filter((optionId) => optionId !== id &&
+                selectOptionReference(optionId).meta.type === 'radio').map((optionId) => {
+                const siblingInputValue = selectOptionInputByIndex(optionId, index) === true;
+                const siblingConditionValue = selectOptionConditionValue(id, index) !== false;
+                return (!siblingConditionValue ||
+                    (siblingConditionValue && siblingInputValue));
+            });
+            const hasTruthfullSibling = siblingsMandatoryValues === null || siblingsMandatoryValues === void 0 ? void 0 : siblingsMandatoryValues.includes(true);
+            if (mpi.getState().mandatories.options[parentId] === undefined)
+                return;
+            mpi.dispatch(setMandatoryOptionAction(parentId, index, mandatoryValue || hasTruthfullSibling));
+        }
+        else {
+            if (mpi.getState().mandatories.options[id] === undefined)
+                return;
+            mpi.dispatch(setMandatoryOptionAction(id, index, mandatoryValue));
+        }
+    }
+    const { options, variables } = selectOptionReference(id);
+    if (options && options.length) {
+        options.forEach((optionId) => {
+            watchUpdateOptionInputCondition(mpi, next, {
+                type: UPDATE_OPTION_CONDITION,
+                id: optionId,
+                index,
+                value: selectOptionConditionValue(optionId, index) !== false,
+            }, true);
+        });
+    }
+    if (variables && variables.length) {
+        variables.forEach((variableId) => {
+            watchUpdateVariableInputCondition(mpi, next, {
+                type: UPDATE_VARIABLE_CONDITION,
+                id: variableId,
+                index,
+                value: selectVariableConditionValue(variableId, index) !== false,
+            }, true);
+        });
+    }
+};
+const watchFetchModelSucceeded = (mpi, next, action) => {
+    next(action);
+    Object.keys(selectAllSectionsReferences() || {}).forEach((id) => {
+        validateSectionMandatory(mpi, parseInt(id, 10));
+    });
+};
+const watchersEnum = {
+    [UPDATE_OPTION_INPUT]: watchUpdateOptionInputCondition,
+    [UPDATE_OPTION_CONDITION]: watchUpdateOptionInputCondition,
+    [UPDATE_VARIABLE_INPUT]: watchUpdateVariableInputCondition,
+    [UPDATE_VARIABLE_CONDITION]: watchUpdateVariableInputCondition,
+    [ADD_MULTIPLE_OCCURENCY]: watchSectionMandatory,
+    [DELETE_MULTIPLE_OCCURENCY]: watchSectionMandatory,
+    [SET_MANDATORY_OPTION]: watchSectionMandatory,
+    [SET_MANDATORY_VARIABLE]: watchSectionMandatory,
+    [UPDATE_SECTION_CONDITION]: watchSectionMandatory,
+    [FETCH_MODEL_SUCCEEDED]: watchFetchModelSucceeded,
+};
+const mandatoriesWatcherMiddleware = (mpi) => (next) => (action) => {
+    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type)) {
+        return watchersEnum[action.type].apply(null, [mpi, next, action]);
+    }
+    return next(action);
+};
+export default mandatoriesWatcherMiddleware;

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

@@ -0,0 +1,5 @@
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { ActionsType } from '../../types/Actions.type';
+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.js

@@ -0,0 +1,43 @@
+import { ADD_MULTIPLE_OCCURENCY, DELETE_MULTIPLE_OCCURENCY, } from '../constants/inputs';
+import { selectOptionRelations, selectOptionReference, selectVariableReference, } from '../selectors/references';
+const completeAddMultipleOccurency = (mpi, next, action) => {
+    const { id } = action;
+    const optionRelations = selectOptionRelations(id);
+    const optionsIds = [
+        id,
+        ...optionRelations.children.options,
+        ...optionRelations.dependants,
+    ];
+    const optionsReferences = {};
+    optionsIds.forEach((currentOptionId) => {
+        optionsReferences[currentOptionId] = selectOptionReference(currentOptionId);
+    });
+    const statePrefillers = mpi.getState().conditions.prefillers;
+    const conditionnedPrefillers = Object.keys(statePrefillers).map((currentId) => parseInt(currentId, 10));
+    const prefillersIds = optionRelations.children.variables.filter((currentId) => conditionnedPrefillers.includes(currentId));
+    const prefillersVariables = {};
+    prefillersIds.forEach((currentVariableId) => {
+        prefillersVariables[currentVariableId] =
+            selectVariableReference(currentVariableId).prefillings;
+    });
+    const completedAction = Object.assign(Object.assign({}, action), { optionRelations,
+        optionsReferences,
+        prefillersVariables });
+    next(completedAction);
+};
+const completeDeleteMultipleOccurency = (mpi, next, action) => {
+    const { id } = action;
+    const optionRelations = selectOptionRelations(id);
+    const completedAction = Object.assign(Object.assign({}, action), { optionRelations });
+    next(completedAction);
+};
+const watchersEnum = {
+    [ADD_MULTIPLE_OCCURENCY]: completeAddMultipleOccurency,
+    [DELETE_MULTIPLE_OCCURENCY]: completeDeleteMultipleOccurency,
+};
+const multiplesActionsMiddleware = (mpi) => (next) => (action) => {
+    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type))
+        return watchersEnum[action.type].apply(null, [mpi, next, action]);
+    return next(action);
+};
+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

@@ -0,0 +1,6 @@
+import { LocationChangeAction } from 'connected-react-router';
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { ActionsType } from '../../types/Actions.type';
+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/paginationWatcherMiddleware.js

@@ -0,0 +1,111 @@
+import { LOCATION_CHANGE } from 'connected-react-router';
+import { goPageAction, updateAvailableSectionsAction, initMetaAction, initInstanceAction, } from '../actions/app';
+import { UPDATE_SECTION_CONDITION } from '../constants/conditions';
+import { selectAllSectionsReferences, selectUserEmailSectionVariableIds, } from '../selectors/references';
+import { selectSectionConditionValue } from '../selectors/conditions';
+import { isLevelAccessibleForUser, selectUserEmail } from '../selectors/user';
+import { selectAvailableSections, selectPermalink, selectCurrentPage, isStepAvailable, selectCurrentSectionId, } from '../selectors/app';
+import { GO_PAGE, GO_NEXT_PAGE, GO_PREVIOUS_PAGE, FETCH_MODEL_SUCCEEDED, } from '../constants/app';
+import { getHistory } from '../routerHistory';
+import { PathReader } from '../../libs/PathReader';
+import { selectVariableInputByIndex } from '../selectors/inputs';
+import { setUserEmail } from '../actions/sagas/user';
+const watchFetchModelSucceeded = (mpi, next, action) => {
+    const result = next(action);
+    const pathReader = new PathReader(mpi.getState());
+    mpi.dispatch(goPageAction(pathReader.currentPage, false));
+    return result;
+};
+const watchLocationChange = (mpi, next, action) => {
+    const result = next(action);
+    const pathReader = new PathReader(mpi.getState());
+    if (selectPermalink() === '') {
+        mpi.dispatch(initMetaAction({
+            permalink: pathReader.currentPermalink,
+            prefix: pathReader.prefix,
+            id: 0,
+            title: '',
+            modelVersion: 0,
+            productType: '',
+        }));
+        if (pathReader.currentUniqid !== undefined) {
+            mpi.dispatch(initInstanceAction({
+                dataStatus: 'saved',
+                uniqid: pathReader.currentUniqid,
+                steps: [1],
+            }));
+        }
+    }
+    mpi.dispatch(goPageAction(pathReader.currentPage, false));
+    mpi.dispatch({ type: 'SET_DEFAULTS' });
+    return result;
+};
+const watchSectionConditionUpdate = (mpi, next, action) => {
+    const result = next(action);
+    const sectionsReferences = selectAllSectionsReferences();
+    if (sectionsReferences === undefined)
+        throw new Error(`Sections references not found`);
+    const availableSections = Object.keys(sectionsReferences)
+        .filter((sectionId) => {
+        const condition = selectSectionConditionValue(parseInt(sectionId, 10)) !== false;
+        const sectionReference = sectionsReferences[sectionId];
+        const sectionGrantLevel = sectionReference.grantLevel
+            ? sectionReference.grantLevel
+            : 'GUEST';
+        const grant = isLevelAccessibleForUser(sectionGrantLevel);
+        const availableStep = isStepAvailable(sectionReference.step);
+        return condition && grant && availableStep;
+    })
+        .map((c) => parseInt(c, 10));
+    const currentAvailableSectionsReduced = selectAvailableSections().reduce((p, c) => `${p} ${c.toString()}`, '');
+    const nextvailableSectionsReduced = availableSections.reduce((p, c) => `${p} ${c.toString()}`, '');
+    if (currentAvailableSectionsReduced !== nextvailableSectionsReduced) {
+        mpi.dispatch(updateAvailableSectionsAction(availableSections));
+    }
+    return result;
+};
+const watchGoPage = (mpi, next, action) => {
+    const state = mpi.getState();
+    if (state.app.pagination.currentAppState === 'wizard') {
+        mpi.dispatch({ type: 'SET_DEFAULTS' });
+    }
+    const result = next(action);
+    if (action.pushHistory === true) {
+        const pathReader = new PathReader(mpi.getState());
+        const currentPage = selectCurrentPage();
+        const path = pathReader.parsePath(currentPage);
+        getHistory().push(path);
+    }
+    return result;
+};
+const watchNextPreviousPage = (mpi, next, action) => {
+    const state = mpi.getState();
+    if (state.app.pagination.currentAppState === 'wizard') {
+        mpi.dispatch({ type: 'SET_DEFAULTS' });
+    }
+    const sectionUserEmailVariables = selectUserEmailSectionVariableIds(selectCurrentSectionId());
+    if (sectionUserEmailVariables.length && !selectUserEmail()) {
+        const [firstUserEmailVariable] = sectionUserEmailVariables;
+        const userEmail = selectVariableInputByIndex(parseInt(firstUserEmailVariable, 10), 0);
+        mpi.dispatch(setUserEmail(userEmail, true, true));
+    }
+    const result = next(action);
+    const pathReader = new PathReader(mpi.getState());
+    const path = pathReader.parsePath(selectCurrentPage());
+    getHistory().push(path);
+    return result;
+};
+const watchersEnum = {
+    [LOCATION_CHANGE]: watchLocationChange,
+    [UPDATE_SECTION_CONDITION]: watchSectionConditionUpdate,
+    [GO_PAGE]: watchGoPage,
+    [GO_NEXT_PAGE]: watchNextPreviousPage,
+    [GO_PREVIOUS_PAGE]: watchNextPreviousPage,
+    [FETCH_MODEL_SUCCEEDED]: watchFetchModelSucceeded,
+};
+const paginationWatcherMiddleware = (mpi) => (next) => (action) => {
+    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type))
+        return watchersEnum[action.type].apply(null, [mpi, next, action]);
+    return next(action);
+};
+export default paginationWatcherMiddleware;

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

@@ -0,0 +1,3 @@
+import { 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

@@ -0,0 +1,10 @@
+import { RunActionAnchor, RunOverrideActionAnchor } from '../../PluginLoader';
+const pluginsHookMiddleware = (mpi) => (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

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