@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/middlewares/conditionsWatcherMiddleware.test.ts

@@ -0,0 +1,370 @@
+import conditionsWatcherMiddleware from './conditionsWatcherMiddleware';
+import {
+  addMultipleOccurencyAction,
+  deleteMultipleOccurencyAction,
+  updateOptionAction,
+  updateVariableAction,
+} from '../actions/inputs';
+import { StateType } from '../../types/State.type';
+import { initConditionsAction } from '../actions/conditions';
+
+const mockInputs: StateType.Inputs = {
+  variables: {
+    1: ['Hello'],
+    2: [],
+    3: [],
+  },
+  options: {
+    1: [true],
+    2: [true, true],
+    3: [true, false],
+    4: [false, true],
+    7: [true, true],
+    8: [true, true],
+  },
+};
+
+// Mocking MPI
+const mpi = {
+  dispatch: jest.fn(),
+  getState: () => ({
+    inputs: mockInputs,
+  }),
+};
+
+// Mocking Next
+const next = jest.fn();
+
+const initialConditions = {
+  options: {},
+  variables: {},
+  documents: {},
+  sections: {},
+  prefillers: {},
+  validators: {
+    options: {},
+    variables: {},
+  },
+};
+
+const mockOptionsRelations: StateType.References.Relations['options'] = {
+  2: {
+    options: [],
+    variables: [],
+    sections: {},
+    documents: [],
+    prefillers: [],
+    validators: {
+      options: [],
+      variables: [],
+    },
+    parents: [],
+    children: {
+      options: [3, 4],
+      variables: [2, 3],
+    },
+    dependants: [7, 8],
+  },
+};
+
+// Mocking reference selecteor
+// ../selectors/inputs.ts
+jest.mock('../selectors/inputs', () => ({
+  __esModule: true,
+  selectOptionInput: (id: number) => mockInputs.options[id],
+  selectOptionInputByIndex: (id: number, index: number) =>
+    mockInputs.options[id][index],
+  selectVariableInput: (id: number) => mockInputs.variables[id],
+  selectVariableInputByIndex: (id: number, index: number) =>
+    mockInputs.variables[id][index],
+}));
+
+jest.mock('../../libs/ConditionsRunner', () => {
+  class ConditionsRunnerMock {
+    dispatch: any;
+
+    constructor(dispatch: any) {
+      this.dispatch = dispatch;
+    }
+
+    executeHooks(...args: any[]) {
+      this.dispatch({
+        type: 'EXEC_HOOKS_MOCK',
+        arguments: args,
+      });
+    }
+  }
+  return {
+    __esModule: true,
+    ConditionsRunner: ConditionsRunnerMock,
+  };
+});
+
+const mockOptionsConditions: Record<string, any> = {};
+const mockVariablesConditions: Record<string, any> = {};
+
+// Mocking reference selecteor
+// ../selectors/references.ts
+jest.mock('../selectors/references', () => ({
+  __esModule: true,
+  selectOptionRelations: (id: number) => mockOptionsRelations[id],
+  selectOptionConditionsObject: (id: number) => mockOptionsConditions[id],
+  selectVariableConditionsObject: (id: number) => mockVariablesConditions[id],
+}));
+
+describe('Conditions Watcher Middleware Test suit', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('Completes INIT_CONDITIONS action correctly', () => {
+    // Running watcher
+    conditionsWatcherMiddleware(mpi)(next)(
+      initConditionsAction(initialConditions)
+    );
+
+    expect(next.mock.calls.length).toBe(1);
+    expect(next.mock.calls[0][0]).toStrictEqual({
+      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', () => {
+    // Running watcher
+    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', () => {
+    // Running watcher
+    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', () => {
+    // Running watcher
+    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', () => {
+    // Running watcher
+    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/src/redux/middlewares/conditionsWatcherMiddleware.ts

@@ -0,0 +1,321 @@
+import { Dispatch, MiddlewareAPI } from 'redux';
+import {
+  UPDATE_OPTION_INPUT,
+  UPDATE_VARIABLE_INPUT,
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import {
+  selectOptionInput,
+  selectOptionInputByIndex,
+  selectVariableInputByIndex,
+  selectVariableInput,
+} from '../selectors/inputs';
+import { ActionsType } from '../../types/Actions.type';
+import { ConditionsRunner } from '../../libs/ConditionsRunner';
+import {
+  INIT_CONDITIONS,
+  UPDATE_SECTION_CONDITION,
+  UPDATE_OPTION_CONDITION,
+  UPDATE_VARIABLE_CONDITION,
+} from '../constants/conditions';
+import {
+  selectOptionRelations,
+  selectOptionConditionsObject,
+  selectVariableConditionsObject,
+} from '../selectors/references';
+import { setDataStatus } from '../actions/app';
+import {
+  selectSectionConditionValue,
+  selectOptionConditionValue,
+  selectVariableConditionValue,
+} from '../selectors/conditions';
+import { StateType } from '../../types/State.type';
+
+export type WatcherActions =
+  | ActionsType.Inputs.updateOptionInput
+  | ActionsType.Inputs.updateVariableInput
+  | ActionsType.Inputs.addMultipleOccurency
+  | ActionsType.Inputs.deleteMultipleOccurency
+  | ActionsType.Conditions.initConditions;
+
+/**
+ * Watching UPDATE_OPTION_INPUT action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateOptionInput = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateOptionInput
+) => {
+  const { id, index, value } = action;
+  const oldValue = selectOptionInputByIndex(id, index);
+
+  const nextResult = next(action);
+  if (value !== oldValue) {
+    mpi.dispatch(setDataStatus('unsaved'));
+    const Conditions = new ConditionsRunner(mpi.dispatch);
+    Conditions.executeHooks('options', id, index);
+  }
+  return nextResult;
+};
+
+/**
+ * Watching UPDATE_OPTION_CONDITION action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateOptionCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Conditions.updateOptionCondition
+) => {
+  const { id, index, value } = action;
+  const oldValue = selectOptionConditionValue(id, index);
+
+  const nextResult = next(action);
+  if (value !== oldValue) {
+    mpi.dispatch(setDataStatus('unsaved'));
+    const Conditions = new ConditionsRunner(mpi.dispatch);
+    Conditions.executeHooks('options', id, index);
+  }
+  return nextResult;
+};
+
+/**
+ * Watching UPDATE_VARIALE_INPUT action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+
+const watchUpdateVariableInput = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateVariableInput
+) => {
+  const { id, index, value } = action;
+  const oldValue = selectVariableInputByIndex(id, index);
+
+  const nextResult = next(action);
+  if (value !== oldValue) {
+    mpi.dispatch(setDataStatus('unsaved'));
+    const Conditions = new ConditionsRunner(mpi.dispatch);
+    Conditions.executeHooks('variables', id, index);
+  }
+  return nextResult;
+};
+
+/**
+ * Watching UPDATE_VARIALE_INPUT action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+
+const watchUpdateVariableCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Conditions.updateVariableCondition
+) => {
+  const { id, index, value } = action;
+  const oldValue = selectVariableConditionValue(id, index);
+
+  const nextResult = next(action);
+  if (value !== oldValue) {
+    mpi.dispatch(setDataStatus('unsaved'));
+    const Conditions = new ConditionsRunner(mpi.dispatch);
+    Conditions.executeHooks('variables', id, index);
+  }
+  return nextResult;
+};
+
+/**
+ * Watching UPDATE_SECTION_CONDITION action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateSectionCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Conditions.updateSectionCondition
+) => {
+  const Conditions = new ConditionsRunner(mpi.dispatch);
+
+  if (action.document !== 'main') {
+    return next(action);
+  }
+
+  const { id, value } = action;
+  const oldValue = selectSectionConditionValue(id);
+
+  const nextResult = next(action);
+  if (value !== oldValue) {
+    Conditions.executeHooks('sections', id, 0);
+  }
+  return nextResult;
+};
+
+/**
+ * Watching ADD_MULTIPLE_OCCURENCY && DELETE_MULTIPLE_OCCURENCY action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+
+const watchMultipleOccurenciesChange = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.deleteMultipleOccurency
+) => {
+  const nextResult = next(action);
+  const Conditions = new ConditionsRunner(mpi.dispatch);
+  mpi.dispatch(setDataStatus('unsaved'));
+
+  const { id } = action;
+
+  // Getting multiple children
+  const optionRelations = selectOptionRelations(id);
+  if (optionRelations === undefined)
+    throw new Error(`Options relations for option ${id} do not exist`);
+
+  // Adding values to input's arrays
+  const options: number[] = [
+    id,
+    ...optionRelations.children.options,
+    ...optionRelations.dependants,
+  ];
+  const { variables } = optionRelations.children;
+
+  // Executing self conditions for options
+  for (let i = 0; i < options.length; i += 1) {
+    // Getting the condition object
+    const condition = selectOptionConditionsObject(options[i]);
+    if (typeof condition === 'object') {
+      // Executing hooks on options
+      condition.dataMap.o.forEach((optionId: number) => {
+        selectOptionInput(optionId).forEach((input, index) =>
+          Conditions.executeHooks('options', optionId, index)
+        );
+      });
+
+      // Executing hooks on variables
+      condition.dataMap.v.forEach((variableId: number) =>
+        selectVariableInput(variableId).forEach((input, index) =>
+          Conditions.executeHooks('variables', variableId, index)
+        )
+      );
+    }
+  }
+
+  // Executing self conditions for variables
+  for (let i = 0; i < variables.length; i += 1) {
+    // Getting the condition object
+    const condition = selectVariableConditionsObject(variables[i]);
+    if (typeof condition === 'object') {
+      // Executing hooks on options
+      condition.dataMap.o.forEach((optionId: number) =>
+        selectOptionInput(optionId).forEach((input, index) =>
+          Conditions.executeHooks('options', optionId, index)
+        )
+      );
+
+      // Executing hooks on variables
+      condition.dataMap.v.forEach((variableId: number) =>
+        selectVariableInput(variableId).forEach((input, index) =>
+          Conditions.executeHooks('variables', variableId, index)
+        )
+      );
+    }
+
+    // Prefillier
+  }
+
+  // Getting occurencies
+  const occurencies = selectOptionInput(id).length;
+
+  // Executing hooks on options
+  for (let i = 0; i < options.length; i += 1) {
+    for (let index = 0; index < occurencies; index += 1) {
+      Conditions.executeHooks('options', options[i], index);
+    }
+  }
+
+  // Executing hooks on variables
+  for (let i = 0; i < variables.length; i += 1) {
+    for (let index = 0; index < occurencies; index += 1) {
+      Conditions.executeHooks('variables', variables[i], index);
+    }
+  }
+  return nextResult;
+};
+
+/**
+ * Watching INIT_CONDITIONS action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchInitConditions = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: WatcherActions
+) => {
+  const nextResult = next(action);
+  const Conditions = new ConditionsRunner(mpi.dispatch);
+  const stateInputs = mpi.getState().inputs;
+  const options = Object.keys(stateInputs.options);
+  const variables = Object.keys(stateInputs.variables);
+
+  // Executing conditions on options
+  for (let i = 0; i < options.length; i += 1) {
+    const values = mpi.getState().inputs.options[parseInt(options[i], 10)];
+    for (let index = 0; index < values.length; index += 1) {
+      Conditions.executeHooks('options', parseInt(options[i], 10), index);
+    }
+  }
+
+  // Executing conditions on variables
+  for (let i = 0; i < variables.length; i += 1) {
+    const values = mpi.getState().inputs.variables[parseInt(variables[i], 10)];
+    for (let index = 0; index < values.length; index += 1) {
+      Conditions.executeHooks('variables', parseInt(variables[i], 10), index);
+    }
+  }
+  return nextResult;
+};
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [UPDATE_OPTION_INPUT]: watchUpdateOptionInput,
+  [UPDATE_OPTION_CONDITION]: watchUpdateOptionCondition,
+  [UPDATE_VARIABLE_INPUT]: watchUpdateVariableInput,
+  [UPDATE_VARIABLE_CONDITION]: watchUpdateVariableCondition,
+  [UPDATE_SECTION_CONDITION]: watchUpdateSectionCondition,
+  [INIT_CONDITIONS]: watchInitConditions,
+  [ADD_MULTIPLE_OCCURENCY]: watchMultipleOccurenciesChange,
+  [DELETE_MULTIPLE_OCCURENCY]: watchMultipleOccurenciesChange,
+};
+
+/**
+ * Condition Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const conditionsWatcherMiddleware =
+  (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => {
+    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type)) {
+      return watchersEnum[action.type].apply(null, [mpi, next, action]);
+    }
+    return next(action);
+  };
+
+export default conditionsWatcherMiddleware;