@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/reducers/conditions/updateVariableValidatorCondition.test.ts

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

package/src/redux/reducers/conditions/updateVariableValidatorCondition.ts

@@ -0,0 +1,28 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+// eslint-disable-next-line max-len
+export const updateVariableValidatorConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateVariableValidatorCondition
+): StateType.Conditions => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.validators.variables[id][index] === value) return state;
+
+  return {
+    ...state,
+    validators: {
+      ...state.validators,
+      variables: {
+        ...state.validators.variables,
+        [id]: [
+          ...state.validators.variables[id].slice(0, index),
+          value,
+          ...state.validators.variables[id].slice(index + 1),
+        ],
+      },
+    },
+  };
+};

package/src/redux/reducers/conditions.test.ts

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

package/src/redux/reducers/conditions.ts

@@ -0,0 +1,68 @@
+import { StateType } from '../../types/State.type';
+import { ConditionsActions } from '../../types/Actions.type';
+import {
+  INIT_CONDITIONS,
+  UPDATE_OPTION_CONDITION,
+  UPDATE_VARIABLE_CONDITION,
+  UPDATE_SECTION_CONDITION,
+  UPDATE_PREFILLER_CONDITION,
+  UPDATE_OPTION_VALIDATOR_CONDITION,
+  UPDATE_VARIABLE_VALIDATOR_CONDITION,
+  UPDATE_DOCUMENT_CONDITION,
+} from '../constants/conditions';
+import { updateOptionConditionReducer } from './conditions/updateOptionConditions';
+import { updateVariableConditionReducer } from './conditions/updateVariableConditions';
+import { initConditionsReducer } from './conditions/initConditions';
+import { updateSectionConditionReducer } from './conditions/updateSectionConditions';
+import { updateDocumentConditionReducer } from './conditions/updateDocumentConditions';
+import { updatePrefillerConditionReducer } from './conditions/updatePrefillerConditions';
+import {
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import { addMultipleOccurencyReducer } from './conditions/addMultipleOccurency';
+import { updateOptionValidatorConditionReducer } from './conditions/updateOptionValidatorCondition';
+import { updateVariableValidatorConditionReducer } from './conditions/updateVariableValidatorCondition';
+import { deleteMultipleOccurencyReducer } from './conditions/deleteMultipleOccurency';
+
+const initialState: StateType.Conditions = {
+  options: {},
+  variables: {},
+  sections: {},
+  documents: {},
+  validators: {
+    options: {},
+    variables: {},
+  },
+  prefillers: {},
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.Conditions, action: any) => StateType.Conditions
+> = {
+  [INIT_CONDITIONS]: initConditionsReducer,
+  [UPDATE_OPTION_CONDITION]: updateOptionConditionReducer,
+  [UPDATE_VARIABLE_CONDITION]: updateVariableConditionReducer,
+  [UPDATE_SECTION_CONDITION]: updateSectionConditionReducer,
+  [UPDATE_DOCUMENT_CONDITION]: updateDocumentConditionReducer,
+  [UPDATE_PREFILLER_CONDITION]: updatePrefillerConditionReducer,
+  [UPDATE_OPTION_VALIDATOR_CONDITION]: updateOptionValidatorConditionReducer,
+  [UPDATE_VARIABLE_VALIDATOR_CONDITION]:
+    updateVariableValidatorConditionReducer,
+  [DELETE_MULTIPLE_OCCURENCY]: deleteMultipleOccurencyReducer,
+  [ADD_MULTIPLE_OCCURENCY]: addMultipleOccurencyReducer,
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const conditionsReducer = (
+  state: StateType.Conditions = initialState,
+  action: ConditionsActions
+): StateType.Conditions => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function')
+    return reducer.apply(null, [state, action]);
+
+  return state;
+};

package/src/redux/reducers/inputs/addMultipleOccurency.test.ts

@@ -0,0 +1,117 @@
+import { OptionV3 } from '@legalplace/models-v3-types';
+import { addMultipleOccurencyReducer } from './addMultipleOccurency';
+import { StateType } from '../../../types/State.type';
+
+const state: StateType.Inputs = {
+  options: {
+    2: [true],
+    3: [false],
+    4: [true],
+  },
+  variables: {
+    2: [''],
+    3: [''],
+  },
+};
+
+describe('addMultipleOccurencyReducer test suit', () => {
+  it('Throws an error if optionRelations or optionsReferences are undefined', () => {
+    expect(() => {
+      // @ts-ignore: Done on puprose to make sure function validates input
+      addMultipleOccurencyReducer(state, {
+        id: 3,
+        optionRelations: undefined,
+        optionsReferences: undefined,
+      });
+    }).toThrowError(
+      'ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding ' +
+        `occurency for 3, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+  });
+
+  it('Adds a multiple occurency conditions correctly', () => {
+    const optionRelations = {
+      options: [],
+      variables: [],
+      sections: {},
+      documents: [],
+      prefillers: [],
+      validators: {
+        options: [],
+        variables: [],
+      },
+      parents: [],
+      children: {
+        options: [3, 4],
+        variables: [2, 3],
+      },
+      dependants: [7, 8],
+    };
+
+    const optionsReferences: Record<string, OptionV3> = {
+      '2': {
+        meta: {
+          id: 2,
+          type: 'static',
+          label: 'Multiple question',
+          step: '*',
+          tags: [],
+          defaultRadio: 4,
+          multiple: {
+            enabled: true,
+          },
+          validator: {},
+        },
+        options: [3, 4],
+        variables: [2, 3],
+      },
+      '3': {
+        meta: {
+          id: 3,
+          type: 'radio',
+          label: 'Option 1',
+          step: '*',
+          tags: [],
+          defaultRadio: 0,
+          validator: {},
+        },
+        options: [],
+        variables: [],
+      },
+      '4': {
+        meta: {
+          id: 4,
+          type: 'radio',
+          label: 'Option 2',
+          step: '*',
+          tags: [],
+          defaultRadio: 0,
+          validator: {},
+        },
+        options: [],
+        variables: [],
+      },
+    };
+
+    const reducerResult = addMultipleOccurencyReducer(state, {
+      id: 2,
+      optionRelations,
+      optionsReferences,
+      type: 'ADD_MULTIPLE_OCCURENCY',
+    });
+
+    expect(reducerResult).toStrictEqual({
+      options: {
+        ...state.options,
+        2: [true, true],
+        3: [false, false],
+        4: [true, false],
+      },
+      variables: {
+        2: ['', ''],
+        3: ['', ''],
+      },
+    });
+  });
+});

package/src/redux/reducers/inputs/addMultipleOccurency.ts

@@ -0,0 +1,50 @@
+/* eslint-disable import/prefer-default-export */
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const addMultipleOccurencyReducer = (
+  state: StateType.Inputs,
+  action: ActionsType.Inputs.addMultipleOccurency
+): StateType.Inputs => {
+  const { id, optionRelations, optionsReferences } = action;
+
+  if (optionRelations === undefined || optionsReferences === undefined)
+    throw new Error(
+      'ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding ' +
+        `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+
+  // Adding values to input's arrays
+  const optionsIds: number[] = [id, ...optionRelations.children.options];
+  const variablesIds: number[] = optionRelations.children.variables;
+
+  // Options list
+  const options: StateType.Inputs.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    const currentOptionReference = optionsReferences[currentOptionId];
+    const optionType = currentOptionReference.meta.type;
+    const defaultValue = !['radio', 'checkbox'].includes(optionType);
+    options[currentOptionId] = [
+      ...state.options[currentOptionId],
+      defaultValue,
+    ];
+  });
+
+  // Variables list
+  const variables: StateType.Inputs.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    variables[currentVariableId] = [...state.variables[currentVariableId], ''];
+  });
+
+  return {
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+  };
+};

package/src/redux/reducers/inputs/deleteMultipleOccurency.test.ts

@@ -0,0 +1,70 @@
+import { deleteMultipleOccurencyReducer } from './deleteMultipleOccurency';
+import { StateType } from '../../../types/State.type';
+
+const state: StateType.Inputs = {
+  options: {
+    2: [true, true, true],
+    3: [false, true, true],
+    4: [true, true, false],
+  },
+  variables: {
+    2: ['21', '22', '23'],
+    3: ['31', '32', '33'],
+  },
+};
+
+describe('deleteMultipleOccurencyReducer test suit', () => {
+  it('Throws an error if optionRelations are undefined', () => {
+    expect(() => {
+      // @ts-ignore: Done on purpose to make sure function validates input
+      deleteMultipleOccurencyReducer(state, {
+        id: 3,
+        optionRelations: undefined,
+      });
+    }).toThrowError(
+      'DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing ' +
+        `occurency for 3, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+  });
+
+  it('Deletes a multiple occurency conditions correctly', () => {
+    const optionRelations = {
+      options: [],
+      variables: [],
+      sections: {},
+      documents: [],
+      prefillers: [],
+      validators: {
+        options: [],
+        variables: [],
+      },
+      parents: [],
+      children: {
+        options: [3, 4],
+        variables: [2, 3],
+      },
+      dependants: [7, 8],
+    };
+
+    const reducerResult = deleteMultipleOccurencyReducer(state, {
+      id: 2,
+      index: 1,
+      optionRelations,
+      type: 'DELETE_MULTIPLE_OCCURENCY',
+    });
+
+    expect(reducerResult).toStrictEqual({
+      options: {
+        ...state.options,
+        2: [true, true],
+        3: [false, true],
+        4: [true, false],
+      },
+      variables: {
+        2: ['21', '23'],
+        3: ['31', '33'],
+      },
+    });
+  });
+});

package/src/redux/reducers/inputs/deleteMultipleOccurency.ts

@@ -0,0 +1,50 @@
+/* eslint-disable import/prefer-default-export */
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const deleteMultipleOccurencyReducer = (
+  state: StateType.Inputs,
+  action: ActionsType.Inputs.deleteMultipleOccurency
+): StateType.Inputs => {
+  const { id, index, optionRelations } = action;
+
+  if (optionRelations === undefined)
+    throw new Error(
+      'DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing ' +
+        `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+
+  // Adding values to input's arrays
+  const optionsIds: number[] = [id, ...optionRelations.children.options];
+  const variablesIds: number[] = optionRelations.children.variables;
+
+  // Options list
+  const options: StateType.Inputs.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    options[currentOptionId] = [
+      ...state.options[currentOptionId].slice(0, index),
+      ...state.options[currentOptionId].slice(index + 1),
+    ];
+  });
+
+  // Variables list
+  const variables: StateType.Inputs.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    variables[currentVariableId] = [
+      ...state.variables[currentVariableId].slice(0, index),
+      ...state.variables[currentVariableId].slice(index + 1),
+    ];
+  });
+
+  return {
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+  };
+};

package/src/redux/reducers/inputs/initOption.ts

@@ -0,0 +1,16 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const initOptionReducer = (
+  state: StateType.Inputs,
+  action: ActionsType.Inputs.initOption
+): StateType.Inputs => {
+  const { id, values } = action;
+  return {
+    ...state,
+    options: {
+      ...state.options,
+      [id]: values,
+    },
+  };
+};