@legalplace/wizardx-core 0.0.1-alpha.0

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

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

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

@@ -0,0 +1,24 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateOptionInputReducer = (
+  state: StateType.Inputs,
+  action: ActionsType.Inputs.updateOptionInput
+): StateType.Inputs => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.options[id][index] === value) return state;
+
+  return {
+    ...state,
+    options: {
+      ...state.options,
+      [id]: [
+        ...state.options[id].slice(0, index),
+        value,
+        ...state.options[id].slice(index + 1),
+      ],
+    },
+  };
+};

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

@@ -0,0 +1,24 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateVariableInputReducer = (
+  state: StateType.Inputs,
+  action: ActionsType.Inputs.updateVariableInput
+): StateType.Inputs => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.variables[id][index] === value) return state;
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      [id]: [
+        ...state.variables[id].slice(0, index),
+        value,
+        ...state.variables[id].slice(index + 1),
+      ],
+    },
+  };
+};

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

@@ -0,0 +1,221 @@
+import { initOptionReducer } from './inputs/initOption';
+import { updateOptionInputReducer } from './inputs/updateOptionInput';
+import { inputsReducer } from './inputs';
+import { initVariableReducer } from './inputs/initVariable';
+import { updateVariableInputReducer } from './inputs/updateVariableInput';
+
+describe('Inputs Options Reducer', () => {
+  // init option reducer
+  it('initOption Reducer', () => {
+    const reducer = initOptionReducer(
+      {
+        variables: {},
+        options: {},
+      },
+      {
+        type: 'INIT_OPTION',
+        id: 123,
+        values: [false],
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {},
+      options: {
+        123: [false],
+      },
+    });
+  });
+
+  // update option reducer
+  it('updateOptionInput Reducer', () => {
+    const reducer = updateOptionInputReducer(
+      {
+        variables: {},
+        options: {
+          123: [false, false, false],
+        },
+      },
+      {
+        type: 'UPDATE_OPTION_INPUT',
+        id: 123,
+        value: true,
+        index: 1,
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {},
+      options: {
+        123: [false, true, false],
+      },
+    });
+  });
+
+  // Update option reducer
+  it('updateOptionInput Reducer (When values did not change)', () => {
+    const initial = {
+      variables: {},
+      options: {
+        123: [false, false, false],
+      },
+    };
+
+    const reducer = updateOptionInputReducer(initial, {
+      type: 'UPDATE_OPTION_INPUT',
+      id: 123,
+      value: false,
+      index: 1,
+    });
+
+    return expect(reducer === initial).toBeTruthy();
+  });
+
+  // init variable reducer
+  it('initVariable Reducer', () => {
+    const reducer = initVariableReducer(
+      {
+        variables: {},
+        options: {},
+      },
+      {
+        type: 'INIT_VARIABLE',
+        id: 123,
+        values: [''],
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {
+        123: [''],
+      },
+      options: {},
+    });
+  });
+
+  // Update variable input reducer
+  it('updateVariableInput Reducer', () => {
+    const reducer = updateVariableInputReducer(
+      {
+        variables: {
+          123: ['', '', ''],
+        },
+        options: {},
+      },
+      {
+        type: 'UPDATE_VARIABLE_INPUT',
+        id: 123,
+        value: 232,
+        index: 2,
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {
+        123: ['', '', 232],
+      },
+      options: {},
+    });
+  });
+
+  // Update variable input reducer
+  it('updateVariableInput Reducer (Value did not change', () => {
+    const initial = {
+      variables: {
+        123: ['', 'Hello', ''],
+      },
+      options: {},
+    };
+
+    const reducer = updateVariableInputReducer(initial, {
+      type: 'UPDATE_VARIABLE_INPUT',
+      id: 123,
+      value: 'Hello',
+      index: 1,
+    });
+
+    return expect(reducer === initial).toBeTruthy();
+  });
+
+  // Inputs reducer INIT_OPTION Action
+  it('inputsReducer INIT_OPTION ACTION', () => {
+    const reducer = inputsReducer(undefined, {
+      type: 'INIT_OPTION',
+      id: 323,
+      values: [true],
+    });
+
+    return expect(reducer).toStrictEqual({
+      variables: {},
+      options: {
+        323: [true],
+      },
+    });
+  });
+
+  // Inputs reducer UPDATE_OPTION_INPUT Action
+  it('inputsReducer UPDATE_OPTION_INPUT ACTION', () => {
+    const reducer = inputsReducer(
+      {
+        variables: {},
+        options: {
+          123: [false, false, false],
+        },
+      },
+      {
+        type: 'UPDATE_OPTION_INPUT',
+        id: 123,
+        value: true,
+        index: 1,
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {},
+      options: {
+        123: [false, true, false],
+      },
+    });
+  });
+
+  // Inputs variables reducer INIT_VARIABLE Action
+  it('inputsVariablesReducer INIT_VARIABLE ACTION', () => {
+    const reducer = inputsReducer(undefined, {
+      type: 'INIT_VARIABLE',
+      id: 323,
+      values: [''],
+    });
+
+    return expect(reducer).toStrictEqual({
+      variables: {
+        323: [''],
+      },
+      options: {},
+    });
+  });
+
+  // Inputs variables reducer UPDATE_VARIABLE_INPUT Action
+  it('inputsVariablesReducer UPDATE_VARIABLE_INPUT ACTION', () => {
+    const reducer = inputsReducer(
+      {
+        variables: {
+          323: ['', '', ''],
+        },
+        options: {},
+      },
+      {
+        type: 'UPDATE_VARIABLE_INPUT',
+        id: 323,
+        value: 'John',
+        index: 0,
+      }
+    );
+
+    return expect(reducer).toStrictEqual({
+      variables: {
+        323: ['John', '', ''],
+      },
+      options: {},
+    });
+  });
+});

package/src/redux/reducers/inputs.ts

@@ -0,0 +1,51 @@
+import { StateType } from '../../types/State.type';
+import { InputsActions } from '../../types/Actions.type';
+import {
+  INIT_OPTION,
+  INIT_VARIABLE,
+  UPDATE_OPTION_INPUT,
+  UPDATE_VARIABLE_INPUT,
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import { initOptionReducer } from './inputs/initOption';
+import { updateOptionInputReducer } from './inputs/updateOptionInput';
+import { initVariableReducer } from './inputs/initVariable';
+import { updateVariableInputReducer } from './inputs/updateVariableInput';
+import { addMultipleOccurencyReducer } from './inputs/addMultipleOccurency';
+import { deleteMultipleOccurencyReducer } from './inputs/deleteMultipleOccurency';
+
+// export const inputsReducer = combineReducers({
+//   options: inputsOptionReducer,
+//   variables: inputsVariableReducer
+// })
+
+const initialState: StateType.Inputs = {
+  options: {},
+  variables: {},
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.Inputs, action: any) => StateType.Inputs
+> = {
+  [INIT_OPTION]: initOptionReducer,
+  [UPDATE_OPTION_INPUT]: updateOptionInputReducer,
+  [INIT_VARIABLE]: initVariableReducer,
+  [UPDATE_VARIABLE_INPUT]: updateVariableInputReducer,
+  [ADD_MULTIPLE_OCCURENCY]: addMultipleOccurencyReducer,
+  [DELETE_MULTIPLE_OCCURENCY]: deleteMultipleOccurencyReducer,
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const inputsReducer = (
+  state: StateType.Inputs = initialState,
+  action: InputsActions
+): StateType.Inputs => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function')
+    return reducer.apply(null, [state, action]);
+
+  return state;
+};

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

@@ -0,0 +1,52 @@
+/* eslint-disable import/prefer-default-export */
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const addMultipleOccurencyReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Inputs.addMultipleOccurency
+): StateType.Mandatories => {
+  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.Mandatories.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    if (Object.prototype.hasOwnProperty.call(state.options, currentOptionId))
+      options[currentOptionId] = [...state.options[currentOptionId], false];
+  });
+
+  // Variables list
+  const variables: StateType.Mandatories.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    if (
+      Object.prototype.hasOwnProperty.call(state.variables, currentVariableId)
+    )
+      variables[currentVariableId] = [
+        ...state.variables[currentVariableId],
+        false,
+      ];
+  });
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+  };
+};

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

@@ -0,0 +1,55 @@
+/* eslint-disable import/prefer-default-export */
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const deleteMultipleOccurencyReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Inputs.deleteMultipleOccurency
+): StateType.Mandatories => {
+  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.Mandatories.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    if (Object.prototype.hasOwnProperty.call(state.options, currentOptionId))
+      options[currentOptionId] = [
+        ...state.options[currentOptionId].slice(0, index),
+        ...state.options[currentOptionId].slice(index + 1),
+      ];
+  });
+
+  // Variables list
+  const variables: StateType.Mandatories.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    if (
+      Object.prototype.hasOwnProperty.call(state.variables, currentVariableId)
+    )
+      variables[currentVariableId] = [
+        ...state.variables[currentVariableId].slice(0, index),
+        ...state.variables[currentVariableId].slice(index + 1),
+      ];
+  });
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+  };
+};

package/src/redux/reducers/mandatories/initMandatoryOption.ts

@@ -0,0 +1,17 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const initMandatoryOptionReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.initMandatoryOption
+): StateType.Mandatories => {
+  const { id, value } = action;
+
+  return {
+    ...state,
+    options: {
+      ...state.options,
+      [id]: value,
+    },
+  };
+};

package/src/redux/reducers/mandatories/initMandatoryVariable.ts

@@ -0,0 +1,17 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const initMandatoryVariableReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.initMandatoryVariable
+): StateType.Mandatories => {
+  const { id, value } = action;
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      [id]: value,
+    },
+  };
+};

package/src/redux/reducers/mandatories/setMandatoryIgnore.ts

@@ -0,0 +1,17 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const setMandatoryIgnoreReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.setMandatoryIgnore
+): StateType.Mandatories => {
+  const { value } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.ignore === value) return state;
+
+  return {
+    ...state,
+    ignore: value,
+  };
+};

package/src/redux/reducers/mandatories/setMandatoryOption.ts

@@ -0,0 +1,25 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const setMandatoryOptionReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.setMandatoryOption
+): StateType.Mandatories => {
+  const { id, index, value } = action;
+
+  if (state.options[id] && state.options[id][index] === value)
+    // Making sure value has changed before changing the state
+    return state;
+
+  return {
+    ...state,
+    options: {
+      ...state.options,
+      [id]: [
+        ...state.options[id].slice(0, index),
+        value,
+        ...state.options[id].slice(index + 1),
+      ],
+    },
+  };
+};

package/src/redux/reducers/mandatories/setMandatorySection.ts

@@ -0,0 +1,20 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const setMandatorySectionReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.setMandatorySection
+): StateType.Mandatories => {
+  const { id, value } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.sections[id] === value) return state;
+
+  return {
+    ...state,
+    sections: {
+      ...state.sections,
+      [id]: value,
+    },
+  };
+};

package/src/redux/reducers/mandatories/setMandatoryVariable.ts

@@ -0,0 +1,24 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const setMandatoryVariableReducer = (
+  state: StateType.Mandatories,
+  action: ActionsType.Mandatories.setMandatoryVariable
+): StateType.Mandatories => {
+  const { id, index, value } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.variables[id] && state.variables[id][index] === value) return state;
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      [id]: [
+        ...state.variables[id].slice(0, index),
+        value,
+        ...state.variables[id].slice(index + 1),
+      ],
+    },
+  };
+};

package/src/redux/reducers/mandatories.ts

@@ -0,0 +1,56 @@
+import { StateType } from '../../types/State.type';
+import { MandatoriesActions } from '../../types/Actions.type';
+import {
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import { addMultipleOccurencyReducer } from './mandatories/addMultipleOccurency';
+import { deleteMultipleOccurencyReducer } from './mandatories/deleteMultipleOccurency';
+import {
+  INIT_MANDATORY_OPTION,
+  INIT_MANDATORY_VARIABLE,
+  SET_MANDATORY_IGNORE,
+  SET_MANDATORY_SECTION,
+  SET_MANDATORY_OPTION,
+  SET_MANDATORY_VARIABLE,
+} from '../constants/mandatories';
+import { initMandatoryOptionReducer } from './mandatories/initMandatoryOption';
+import { initMandatoryVariableReducer } from './mandatories/initMandatoryVariable';
+import { setMandatoryIgnoreReducer } from './mandatories/setMandatoryIgnore';
+import { setMandatorySectionReducer } from './mandatories/setMandatorySection';
+import { setMandatoryOptionReducer } from './mandatories/setMandatoryOption';
+import { setMandatoryVariableReducer } from './mandatories/setMandatoryVariable';
+
+const initialState: StateType.Mandatories = {
+  ignore: true,
+  sections: {},
+  options: {},
+  variables: {},
+};
+
+const reducersEnum: Record<
+  string,
+  (state: StateType.Mandatories, action: any) => StateType.Mandatories
+> = {
+  [ADD_MULTIPLE_OCCURENCY]: addMultipleOccurencyReducer,
+  [DELETE_MULTIPLE_OCCURENCY]: deleteMultipleOccurencyReducer,
+  [INIT_MANDATORY_OPTION]: initMandatoryOptionReducer,
+  [INIT_MANDATORY_VARIABLE]: initMandatoryVariableReducer,
+  [SET_MANDATORY_IGNORE]: setMandatoryIgnoreReducer,
+  [SET_MANDATORY_SECTION]: setMandatorySectionReducer,
+  [SET_MANDATORY_OPTION]: setMandatoryOptionReducer,
+  [SET_MANDATORY_VARIABLE]: setMandatoryVariableReducer,
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const mandatoriesReducer = (
+  state: StateType.Mandatories = initialState,
+  action: MandatoriesActions
+): StateType.Mandatories => {
+  const reducer = reducersEnum[action.type];
+
+  if (typeof reducer === 'function')
+    return reducer.apply(null, [state, action]);
+
+  return state;
+};

package/src/redux/reducers/references/initReferences.ts

@@ -0,0 +1,37 @@
+import { StateType } from '../../../types/State.type';
+import { ActionsType } from '../../../types/Actions.type';
+
+/**
+ * References initiation reducer
+ * @param action INIT_REFERENCE Action
+ */
+export const initReferencesReducer = (
+  state: StateType.References,
+  action: ActionsType.References.initReferences
+): StateType.References => {
+  const {
+    options,
+    variables,
+    conditions,
+    relations,
+    sections,
+    defaults,
+    evaluations,
+    outputs,
+    boxes,
+    documents,
+  } = action;
+  return {
+    ...state,
+    options,
+    variables,
+    conditions,
+    relations,
+    sections,
+    defaults,
+    evaluations,
+    outputs,
+    boxes,
+    documents,
+  };
+};