@legalplace/wizardx-core 0.0.1-alpha.0

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

@@ -0,0 +1,92 @@
+import { createAppStore, getStore } from '../store';
+import { initConditionsAction } from '../actions/conditions';
+import {
+  selectOptionConditionValue,
+  selectVariableConditionValue,
+  selectSectionConditionValue,
+  selectPrefillerConditionValue,
+  selectOptionValidatorConditionValue,
+  selectVariableValidatorConditionValue,
+} from './conditions';
+
+// Initiating state
+createAppStore('memory');
+const store = getStore();
+
+// Initiating conditions
+store.dispatch(
+  initConditionsAction({
+    options: {
+      34: [false, true],
+    },
+    variables: {
+      33: [false, true],
+    },
+    prefillers: {
+      53: [[false], [true]],
+    },
+    sections: {
+      main: {
+        31: false,
+      },
+    },
+    documents: {
+      main: true,
+    },
+    validators: {
+      options: {
+        234: [false],
+      },
+      variables: {
+        124: [true],
+      },
+    },
+  })
+);
+
+describe('Conditions selectors test suit', () => {
+  it('Selects option conditions correctly (all occurencies)', () => {
+    const condition = selectOptionConditionValue(34);
+    expect(condition).toEqual([false, true]);
+  });
+
+  it('Selects option conditions correctly (specific occurency)', () => {
+    const condition = selectOptionConditionValue(34, 1);
+    expect(condition).toBeTruthy();
+  });
+
+  it('Selects variable conditions correctly (all occurencies)', () => {
+    const condition = selectVariableConditionValue(33);
+    expect(condition).toEqual([false, true]);
+  });
+
+  it('Selects variable conditions correctly (specific occurency)', () => {
+    const condition = selectVariableConditionValue(33, 1);
+    expect(condition).toBeTruthy();
+  });
+
+  it('Selects section conditions correctly ', () => {
+    const condition = selectSectionConditionValue(31);
+    expect(condition).toBeFalsy();
+  });
+
+  it('Selects prefiller conditions correctly (all occurencies)', () => {
+    const condition = selectPrefillerConditionValue(53);
+    expect(condition).toEqual([[false], [true]]);
+  });
+
+  it('Selects prefiller conditions correctly (specific occurency)', () => {
+    const condition = selectPrefillerConditionValue(53, 1);
+    expect(condition).toEqual([true]);
+  });
+
+  it('Selects option validator conditions correctly', () => {
+    const condition = selectOptionValidatorConditionValue(234);
+    expect(condition).toEqual([false]);
+  });
+
+  it('Selects variable validator conditions correctly', () => {
+    const condition = selectVariableValidatorConditionValue(124);
+    expect(condition).toEqual([true]);
+  });
+});

package/src/redux/selectors/conditions.ts

@@ -0,0 +1,293 @@
+import { createSelector } from './selectors';
+import { StateType } from '../../types/State.type';
+import {
+  selectVariableParents,
+  selectOptionParents,
+  selectVariableParentSection,
+  selectOptionParentSection,
+} from './references';
+import { selectOptionInputByIndex } from './inputs';
+
+/**
+ * Returns option's condition value
+ * @param id Option's id
+ * @param index Occuency's index
+ */
+
+// Let's start by creation the selector
+const optionConditionValueSelector = createSelector(
+  (state: StateType, id: number, index?: number) => {
+    if (typeof state.conditions.options[id] === 'undefined') return undefined;
+    return typeof index === 'number'
+      ? state.conditions.options[id][index]
+      : state.conditions.options[id];
+  },
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.options[id] === 'undefined')
+      return Math.random();
+    return `${state.conditions.options[id].reduce(
+      (p, c) => p + (c ? '1' : '0'),
+      ''
+    )}_${id}_${index}`;
+  }
+);
+
+// Let's wrap our selector in a function to enable us to have
+// conditional return type
+export function selectOptionConditionValue(
+  id: number
+): Readonly<boolean[] | undefined>;
+export function selectOptionConditionValue(
+  id: number,
+  index: number
+): Readonly<boolean | undefined>;
+export function selectOptionConditionValue(id: number, index?: number) {
+  if (typeof index === 'number') return optionConditionValueSelector(id, index);
+  return optionConditionValueSelector(id);
+}
+
+/**
+ * Returns variable's condition value
+ * @param id Variable's id
+ * @param index Occuency's index
+ */
+const variableConditionValueSelector = createSelector(
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.variables[id] === 'undefined') return undefined;
+    return typeof index === 'number'
+      ? state.conditions.variables[id][index]
+      : state.conditions.variables[id];
+  },
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.variables[id] === 'undefined')
+      return Math.random();
+    return `${state.conditions.variables[id].reduce(
+      (p, c) => p + (c ? '1' : '0'),
+      ''
+    )}_${id}_${index}`;
+  }
+);
+
+// Let's wrap our selector in a function to enable us to have
+// conditional return type
+export function selectVariableConditionValue(id: number): boolean[] | undefined;
+export function selectVariableConditionValue(
+  id: number,
+  index: number
+): boolean | undefined;
+export function selectVariableConditionValue(id: number, index?: number) {
+  if (typeof index === 'number')
+    return variableConditionValueSelector(id, index);
+  return variableConditionValueSelector(id);
+}
+
+/**
+ * Returns section's condition value
+ * @param id Section's id
+ */
+export const selectSectionConditionValue = createSelector(
+  (state, id: number, document = 'main') => {
+    if (state.conditions.sections[document] === undefined) return undefined;
+    return state.conditions.sections[document][id];
+  },
+  (state, id: number, document = 'main') => {
+    const key = state.conditions.sections[document][id] ? `1_${id}` : `0_${id}`;
+    return document + key;
+  }
+);
+
+/**
+ * Returns documents's condition value
+ * @param name Document's name
+ */
+export const selectDocumentConditionValue = createSelector(
+  (state, name: string) => {
+    if (typeof state.conditions.documents[name] === 'undefined')
+      return undefined;
+    return state.conditions.documents[name];
+  },
+  (state, name: string) => {
+    if (typeof state.conditions.documents[name] === 'undefined')
+      return Math.random().toString();
+    return state.conditions.documents[name] ? 'true' : 'false';
+  }
+);
+
+/**
+ * Returns prefiller condition's value
+ * @param id Prefiller ID (variable's id)
+ * @param index Occuency's index
+ */
+const prefillerConditionValueSelector = createSelector(
+  (state, id: number, index?: number) => {
+    if (state.conditions.prefillers === undefined) return undefined;
+    if (state.conditions.prefillers[id] === undefined) return undefined;
+    return typeof index === 'number'
+      ? state.conditions.prefillers[id][index]
+      : state.conditions.prefillers[id];
+  },
+  (state, id: number, index?: number) => {
+    const prefillers = state.conditions.prefillers[id].map((v) =>
+      v.reduce((p, c) => p + (c ? '1' : '0'), '')
+    );
+    return `${prefillers.reduce((p, c) => p + c, '')}_${id}_${index}`;
+  }
+);
+
+// Let's wrap our selector in a function to enable us to have
+// conditional return type
+export function selectPrefillerConditionValue(
+  id: number
+): boolean[][] | undefined;
+export function selectPrefillerConditionValue(
+  id: number,
+  index: number
+): boolean[] | undefined;
+export function selectPrefillerConditionValue(id: number, index?: number) {
+  if (typeof index === 'number')
+    return prefillerConditionValueSelector(id, index);
+  return prefillerConditionValueSelector(id);
+}
+
+/**
+ * Returns option validator condition's value
+ * @param id Option ID (variable's id)
+ * @param index Occuency's index
+ */
+const optionValidatorConditionValueSelector = createSelector(
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.validators.options[id] === 'undefined')
+      return undefined;
+    if (
+      typeof index === 'number' &&
+      typeof state.conditions.validators.options[id][index] === 'undefined'
+    )
+      return undefined;
+    return typeof index === 'number'
+      ? state.conditions.validators.options[id][index]
+      : state.conditions.validators.options[id];
+  },
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.validators.options[id] === 'undefined')
+      return Math.random();
+    return `${state.conditions.validators.options[id].reduce(
+      (p, c) => p + (c ? '1' : '0'),
+      ''
+    )}-${id.toString()}${index ? index.toString() : ''}`;
+  }
+);
+
+// Let's wrap our selector in a function to enable us to have
+// conditional return type
+export function selectOptionValidatorConditionValue(
+  id: number
+): boolean[] | undefined;
+export function selectOptionValidatorConditionValue(
+  id: number,
+  index: number
+): boolean | undefined;
+export function selectOptionValidatorConditionValue(
+  id: number,
+  index?: number
+) {
+  if (typeof index === 'number')
+    return optionValidatorConditionValueSelector(id, index);
+  return optionValidatorConditionValueSelector(id);
+}
+
+/**
+ * Returns variable validator condition's value
+ * @param id Variable ID (variable's id)
+ * @param index Occuency's index
+ */
+const variableValidatorConditionValueSelector = createSelector(
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.validators.variables[id] === 'undefined')
+      return undefined;
+    return typeof index === 'number'
+      ? state.conditions.validators.variables[id][index]
+      : state.conditions.validators.variables[id];
+  },
+  (state, id: number, index?: number) => {
+    if (typeof state.conditions.validators.variables[id] === 'undefined')
+      return Math.random();
+    return `${state.conditions.validators.variables[id].reduce(
+      (p, c) => p + (c ? '1' : '0'),
+      ''
+    )}-${id.toString()}${index ? index.toString() : ''}`;
+  }
+);
+
+// Let's wrap our selector in a function to enable us to have
+// conditional return type
+export function selectVariableValidatorConditionValue(
+  id: number
+): boolean[] | undefined;
+export function selectVariableValidatorConditionValue(
+  id: number,
+  index: number
+): boolean | undefined;
+export function selectVariableValidatorConditionValue(
+  id: number,
+  index?: number
+) {
+  if (typeof index === 'number')
+    return variableValidatorConditionValueSelector(id, index);
+  return variableValidatorConditionValueSelector(id);
+}
+
+/**
+ *
+ */
+
+export const selectIsOptionDisplayed = createSelector(
+  (state, id: number, index: number) => {
+    const optionCondition = selectOptionConditionValue(id, index) !== false;
+    const optionParents = selectOptionParents(id);
+    const parentsConditions = optionParents.map((optionId) => {
+      return selectOptionConditionValue(optionId, index) !== false;
+    });
+    const parentsInputs = optionParents.map((optionId) => {
+      return selectOptionInputByIndex(optionId, index);
+    });
+    const parentSectionId = selectOptionParentSection(id);
+    const parentSectionCondition =
+      selectSectionConditionValue(parentSectionId) !== false;
+
+    return (
+      [
+        optionCondition,
+        parentSectionCondition,
+        ...parentsConditions,
+        ...parentsInputs,
+      ].filter((c) => c !== true).length === 0
+    );
+  },
+  () => Math.random()
+);
+
+export const selectIsVariableDisplayed = createSelector(
+  (state, id: number, index: number) => {
+    const variableCondition = selectVariableConditionValue(id, index) !== false;
+    const variableParents = selectVariableParents(id);
+    const parentsConditions = variableParents.map((optionId) => {
+      return selectOptionConditionValue(optionId, index) !== false;
+    });
+    const parentsInputs = variableParents.map((optionId) => {
+      return selectOptionInputByIndex(optionId, index);
+    });
+    const parentSectionId = selectVariableParentSection(id);
+    const parentSectionCondition =
+      selectSectionConditionValue(parentSectionId) !== false;
+
+    return (
+      [
+        variableCondition,
+        parentSectionCondition,
+        ...parentsConditions,
+        ...parentsInputs,
+      ].filter((c) => c !== true).length === 0
+    );
+  },
+  () => Math.random()
+);

package/src/redux/selectors/index.ts

@@ -0,0 +1,7 @@
+export * from './app';
+export * from './conditions';
+export * from './inputs';
+export * from './mandatories';
+export * from './references';
+export * from './smartscript';
+export * from './user';

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

@@ -0,0 +1,72 @@
+import { createAppStore, getStore } from '../store';
+import {
+  selectOptionInput,
+  selectVariableInput,
+  selectVariableInputByIndex,
+  selectOptionInputByIndex,
+  selectInputs,
+} from './inputs';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+
+// Initiating state
+createAppStore('memory');
+const store = getStore();
+
+describe('Inputs selectors test suit', () => {
+  it('Returns Inputs Object properly', () => {
+    // Initiating option
+    store.dispatch(initOptionAction(4, [false, true]));
+    store.dispatch(initOptionAction(5, [true]));
+    store.dispatch(initVariableAction(51, ['Ok', 'Hello']));
+
+    expect(selectInputs()).toEqual({
+      options: {
+        4: [false, true],
+        5: [true],
+      },
+      variables: {
+        51: ['Ok', 'Hello'],
+      },
+    });
+  });
+
+  it('Returns current option input (all occurencies)', () => {
+    // Initiating option
+    store.dispatch(initOptionAction(4, [false, true]));
+
+    const selector = selectOptionInput(4);
+
+    expect(selector).toEqual([false, true]);
+  });
+
+  it('Returns current option input (one occurency)', () => {
+    // Initiating option
+    store.dispatch(initOptionAction(4, [false, true]));
+
+    const selector = selectOptionInputByIndex(4, 1);
+
+    expect(selector).toBeTruthy();
+  });
+
+  it('Returns undefined if option does not exist (one occurency)', () => {
+    expect(selectOptionInputByIndex(44, 1)).toBeUndefined();
+  });
+
+  it('Returns current variable input (all occurencies)', () => {
+    // Initiating variable
+    store.dispatch(initVariableAction(4, ['Hello', 'World']));
+
+    const selector = selectVariableInput(4);
+
+    expect(selector).toEqual(['Hello', 'World']);
+  });
+
+  it('Returns current variable input (one occurency)', () => {
+    // Initiating variable
+    store.dispatch(initVariableAction(4, ['Hello', 'World']));
+
+    const selector = selectVariableInputByIndex(4, 1);
+
+    expect(selector).toBe('World');
+  });
+});

package/src/redux/selectors/inputs.ts

@@ -0,0 +1,76 @@
+import { StateType } from '../../types/State.type';
+import { createSelector } from './selectors';
+
+/**
+ * Returns all inputs
+ */
+export type selectInputsType = () => StateType.Inputs;
+export const selectInputs: selectInputsType = createSelector(
+  (state: StateType) => state.inputs,
+  () => Math.random()
+);
+
+/**
+ * Return all option's input
+ * @param id Option's id
+ */
+export const selectOptionInput = createSelector(
+  (state: StateType, id: number) => state.inputs.options[id],
+  (state: StateType, id: number) =>
+    `${state.inputs.options[id].reduce(
+      (p, c) => p + (c ? '1' : '0'),
+      ''
+    )}_${id.toString()}`
+);
+
+/**
+ * Return option's input
+ * @param id Option's id
+ * @param index Occurency's index
+ */
+export const selectOptionInputByIndex = createSelector(
+  (state: StateType, id: number, index: number) => {
+    if (state.inputs.options[id] === undefined) return undefined;
+    return state.inputs.options[id][index];
+  },
+  (state: StateType, id: number, index?: number) =>
+    state.inputs.options[id] !== undefined
+      ? `${state.inputs.options[id].reduce(
+          (p, c) => p + (c ? '1' : '0'),
+          ''
+        )}_${id.toString()}_${index}`
+      : Math.random()
+);
+
+/**
+ * Return all variable inputs
+ * @param id Variable's id
+ */
+export const selectVariableInput = createSelector(
+  (state: StateType, id: number) => {
+    if (typeof state.inputs.variables[id] === 'undefined') return [''];
+    return state.inputs.variables[id];
+  },
+  (state: StateType, id: number) => {
+    if (typeof state.inputs.variables[id] === 'undefined') return Math.random();
+    return `${state.inputs.variables[id].reduce(
+      (p, c) => `${p}-${c}`,
+      ''
+    )}_${id.toString()}`;
+  }
+);
+
+/**
+ * Return variable's input
+ * @param id Variable's id
+ * @param index Occurency's index
+ */
+export const selectVariableInputByIndex = createSelector(
+  (state: StateType, id: number, index: number) =>
+    state.inputs.variables[id][index],
+  (state: StateType, id: number, index: number) =>
+    `${state.inputs.variables[id].reduce(
+      (p, c) => `${p}-${c}`,
+      ''
+    )}_${id.toString()}_${index}`
+);

package/src/redux/selectors/mandatories.ts

@@ -0,0 +1,83 @@
+import { createSelector } from './selectors';
+
+/**
+ * Returns mandatory ignore
+ */
+export const selectMandatoryIgnore = createSelector(
+  (state) => state.mandatories.ignore,
+  (state) => (state.mandatories.ignore ? '1' : '0')
+);
+
+/**
+ * Returns mandatory section
+ */
+export const selectMandatorySection = createSelector(
+  (state, id: number) => state.mandatories.sections[id] === true,
+  (state, id: number) => `${id}:${state.mandatories.sections[id] ? '1' : '0'}`
+);
+
+/**
+ * Returns mandatory section
+ */
+export const selectFirstUnfinishedSectionId = createSelector(
+  (state, id: number) => {
+    const sectionIds = Object.keys(state.mandatories.sections);
+
+    if (!sectionIds || !sectionIds.length) return id;
+    const extractedSectionIds = sectionIds.slice(
+      0,
+      sectionIds.indexOf(`${id}`) + 1
+    );
+    const firstUnfinishedSectionId =
+      extractedSectionIds.find(
+        (sectionId) => state.mandatories.sections[sectionId] === false
+      ) || `${id}`;
+
+    return parseInt(firstUnfinishedSectionId, 10);
+  }
+);
+
+/**
+ * Returns mandatory option item
+ */
+export const selectMandatoryOptionItem = createSelector(
+  (state, id: number) => state.mandatories.options[id],
+  (state, id: number) => (state.mandatories.options[id] ? '1' : '0')
+);
+/**
+ * Returns mandatory option
+ */
+export const selectMandatoryOption = createSelector(
+  (state, id: number) => state.mandatories.options[id].map((c) => c && true),
+  (state, id: number) =>
+    `${id}:${state.mandatories.options[id]
+      .map((c) => (c ? '1' : '0'))
+      .join('-')}`
+);
+export const selectMandatoryOptionByIndex = createSelector(
+  (state, id: number, index: number) =>
+    state.mandatories.options[id]?.[index] === true,
+  (state, id: number, index: number) =>
+    `${id}-${index}:${
+      state.mandatories.options[id]?.[index] === true ? '1' : '0'
+    }`
+);
+
+/**
+ * Returns mandatory variable
+ */
+export const selectMandatoryVariable = createSelector(
+  (state, id: number) => state.mandatories.variables[id].map((c) => c && true),
+  (state, id: number) =>
+    `${id}:${state.mandatories.variables[id]
+      .map((c) => (c ? '1' : '0'))
+      .join('-')}`
+);
+export const selectMandatoryVariableByIndex = createSelector(
+  (state, id: number, index: number) =>
+    state.mandatories.variables[id]?.[index] === true,
+  (state, id: number, index: number) =>
+    `${id}-${index}:${
+      state.mandatories.variables[id]?.[index] === true ? '1' : '0'
+    }`
+);