@legalplace/wizardx-core 2.6.3 → 2.7.0

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

@@ -1,92 +0,0 @@
-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

@@ -1,293 +0,0 @@
-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) => selectOptionConditionValue(optionId, index) !== false
-    );
-    const parentsInputs = optionParents.map((optionId) =>
-      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) => selectOptionConditionValue(optionId, index) !== false
-    );
-    const parentsInputs = variableParents.map((optionId) =>
-      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/inputs.test.ts

@@ -1,72 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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/library.ts

@@ -1,17 +0,0 @@
-import * as app from "./app";
-import * as conditions from "./conditions";
-import * as inputs from "./inputs";
-import * as mandatories from "./mandatories";
-import * as references from "./references";
-import * as smartscript from "./smartscript";
-import * as user from "./user";
-
-export const selectorsLibrary = {
-  ...app,
-  ...conditions,
-  ...inputs,
-  ...mandatories,
-  ...references,
-  ...smartscript,
-  ...user,
-};

package/src/redux/selectors/mandatories.ts

@@ -1,83 +0,0 @@
-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"
-    }`
-);