@legalplace/wizardx-core 2.6.3 → 2.7.0

package/src/libs/ConditionsRunner/DataPopulator.ts

@@ -1,266 +0,0 @@
-import {
-  selectVariableReference,
-  selectVariableParents,
-  selectOptionRelations,
-  selectOptionParents,
-} from "../../redux/selectors/references";
-import {
-  selectVariableInput,
-  selectOptionInput,
-} from "../../redux/selectors/inputs";
-import {
-  selectVariableConditionValue,
-  selectOptionConditionValue,
-  selectSectionConditionValue,
-} from "../../redux/selectors/conditions";
-
-class DataPopulator {
-  private id?: number;
-
-  private index?: number;
-
-  private dataMap: ConditionDataMap;
-
-  private data: ConditionData = {
-    o: {},
-    v: {},
-    c: {
-      o: {},
-      s: {},
-      v: {},
-    },
-  };
-
-  constructor(dataMap: ConditionDataMap, id?: number, index?: number) {
-    this.id = id;
-    this.index = index;
-    this.dataMap = dataMap;
-
-    // Populating variables
-    this.populateVariables();
-
-    // Populating options
-    this.populateOptions();
-
-    // Populating conditions
-    this.populateConditions();
-  }
-
-  /**
-   * Returns resulting data object
-   */
-  public getData(): Readonly<ConditionData> {
-    return this.data;
-  }
-
-  private populateConditions(): void {
-    // Sections
-    for (let i = 0; i < this.dataMap.c.s.length; i += 1) {
-      const sectionId = this.dataMap.c.s[i];
-      const sectionCondition = selectSectionConditionValue(sectionId);
-      this.data.c.s[sectionId] = [sectionCondition !== false];
-    }
-
-    // Options
-    for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
-      const optionId = this.dataMap.c.o[i];
-      const optionCondition = [...this.getOptionConditions(optionId)];
-      this.data.c.o[optionId] =
-        optionCondition === undefined ? [false] : optionCondition;
-    }
-
-    // Variables
-    for (let i = 0; i < this.dataMap.c.v.length; i += 1) {
-      const variableId = this.dataMap.c.v[i];
-      const variableCondition = [...this.getVariablesConditions(variableId)];
-      this.data.c.v[variableId] =
-        variableCondition === undefined ? [false] : variableCondition;
-    }
-  }
-
-  /**
-   * Returns a give option's conditions
-   * @param optionId Option's id
-   */
-  private getOptionConditions(optionId: number): Readonly<boolean[]> {
-    const conditions = selectOptionConditionValue(optionId);
-    if (conditions === undefined) return [true];
-    if (this.id === undefined || this.index === undefined) {
-      return conditions;
-    }
-
-    // Getting variable parent option
-    const optionRootParent = this.getOptionRootParent(optionId);
-    const optionRootRelations = selectOptionRelations(optionRootParent);
-    if (
-      optionRootRelations.children.options.includes(this.id) ||
-      optionRootRelations.dependants.includes(this.id) ||
-      this.id === optionRootParent
-    ) {
-      if (conditions !== undefined && conditions[this.index] === false)
-        return [false];
-      return [conditions[this.index]];
-    }
-
-    return conditions;
-  }
-
-  /**
-   * Returns a give variables conditions
-   * @param variableId Variable's id
-   */
-  private getVariablesConditions(variableId: number): Readonly<boolean[]> {
-    const conditions = selectVariableConditionValue(variableId);
-    if (conditions === undefined) return [true];
-    if (this.id === undefined || this.index === undefined) {
-      return conditions;
-    }
-
-    // Getting variable parent option
-    const variableRootParent = this.getVariableRootParent(variableId);
-    const variableRootRelations = selectOptionRelations(variableRootParent);
-    if (
-      variableRootRelations.children.options.includes(this.id) ||
-      variableRootRelations.dependants.includes(this.id) ||
-      this.id === variableRootParent
-    ) {
-      return [conditions[this.index]];
-    }
-
-    return conditions;
-  }
-
-  /**
-   * Populates variables according to the current dataMap object
-   */
-  private populateVariables(): void {
-    for (let i = 0; i < this.dataMap.v.length; i += 1) {
-      const variableId = this.dataMap.v[i];
-      const variableReference = selectVariableReference(variableId);
-      let values = this.getVariableValues(variableId);
-
-      // If variable is of type number
-      if (variableReference.type === "number") {
-        values = values
-          .map((v) => (typeof v === "number" ? v : parseFloat(v)))
-          .map((v) => (Number.isNaN(v) ? "" : v));
-      }
-
-      // Adding variables
-      this.data.v[variableId] = [...values];
-    }
-  }
-
-  /**
-   * Returns a give variables value
-   * @param variableId Variable's id
-   */
-  private getVariableValues(variableId: number): Readonly<(string | number)[]> {
-    const value = selectVariableInput(variableId);
-    if (this.id === undefined || this.index === undefined) {
-      return value;
-    }
-
-    // Getting variable parent option
-    const variableRootParent = this.getVariableRootParent(variableId);
-    const variableRootRelations = selectOptionRelations(variableRootParent);
-    if (
-      variableRootRelations.children.options.includes(this.id) ||
-      variableRootRelations.dependants.includes(this.id) ||
-      this.id === variableRootParent
-    ) {
-      return [value[this.index]];
-    }
-
-    return this.cleanArrayFromNullValues([...value]);
-  }
-
-  /**
-   * Return a given variable root option relations
-   * @param variableId Variable's id
-   */
-  private getVariableRootParent(variableId: number) {
-    const variableParents = selectVariableParents(variableId);
-    return variableParents[variableParents.length - 1];
-  }
-
-  /**
-   * Cleans values array from any null value by replacing it
-   * with an empty string
-   * @param arr Values array
-   */
-  private cleanArrayFromNullValues(
-    arr: (string | number | null)[]
-  ): (string | number)[] {
-    return arr.map((v) => (v === null ? "" : v));
-  }
-
-  /**
-   * Populates options data object accodring to current dataMap object
-   */
-  populateOptions() {
-    for (let i = 0; i < this.dataMap.o.length; i += 1) {
-      const optionId = this.dataMap.o[i];
-      const inputs = this.getOptionInputs(optionId);
-
-      // Adding option
-      this.data.o[optionId] = [...inputs];
-    }
-  }
-
-  /**
-   * Returns a give option's inputs
-   * @param optionId Option's id
-   */
-  private getOptionInputs(optionId: number): Readonly<boolean[]> {
-    const inputs = selectOptionInput(optionId);
-    if (this.id === undefined || this.index === undefined) {
-      return inputs;
-    }
-
-    // Getting variable parent option
-    const optionRootParent = this.getOptionRootParent(optionId);
-    const optionRootRelations = selectOptionRelations(optionRootParent);
-    if (
-      optionRootRelations.children.options.includes(this.id) ||
-      optionRootRelations.dependants.includes(this.id) ||
-      this.id === optionRootParent
-    ) {
-      return [inputs[this.index]];
-    }
-    return inputs;
-  }
-
-  /**
-   * Returns option's root parent
-   * @param optionId Root parent
-   */
-  private getOptionRootParent(optionId: number) {
-    const optionParents = selectOptionParents(optionId);
-    return optionParents.length > 0
-      ? optionParents[optionParents.length - 1]
-      : optionId;
-  }
-}
-
-export interface ConditionDataMap {
-  o: number[];
-  v: number[];
-  c: {
-    o: number[];
-    s: number[];
-    v: number[];
-  };
-}
-
-export interface ConditionData {
-  o: Record<string, boolean[]>;
-  v: Record<string, (string | number)[]>;
-  c: {
-    o: Record<string, boolean[]>;
-    s: Record<string, boolean[]>;
-    v: Record<string, boolean[]>;
-  };
-}
-
-export default DataPopulator;

package/src/libs/ConditionsRunner.ts

@@ -1,454 +0,0 @@
-/* eslint-disable max-len */
-import { Dispatch } from "redux";
-import LpLogic from "@legalplace/lplogic/dist/LpLogic";
-import { selectOptionInput } from "../redux/selectors/inputs";
-import {
-  selectOptionRelations,
-  selectVariableRelations,
-  selectVariableParents,
-  selectOptionParents,
-  selectOptionConditionsObject,
-  selectVariableConditionsObject,
-  selectSectionConditionsObject,
-  selectPrefillerConditionsObject,
-  selectOptionValidatorConditionsObject,
-  selectVariableValidatorConditionsObject,
-  selectDocumentConditionsObject,
-  selectOptionReference,
-  selectSectionRelations,
-} from "../redux/selectors/references";
-import {
-  updateOptionConditionsAction,
-  updateVariableConditionsAction,
-  updateSectionConditionsAction,
-  updatePrefillersConditionsAction,
-  updateOptionValidatorConditionsAction,
-  updateVariableValidatorConditionsAction,
-  updateDocumentConditionsAction,
-} from "../redux/actions/conditions";
-import {
-  selectOptionConditionValue,
-  selectVariableConditionValue,
-  selectSectionConditionValue,
-  selectPrefillerConditionValue,
-  selectOptionValidatorConditionValue,
-  selectVariableValidatorConditionValue,
-  selectDocumentConditionValue,
-} from "../redux/selectors/conditions";
-import { StateType, MAPPED_CONDITIONS } from "../types/State.type";
-import DataPopulator from "./ConditionsRunner/DataPopulator";
-
-// eslint-disable-next-line max-len
-export type AllConditions =
-  | StateType.Conditions.Options
-  | StateType.Conditions.Variables
-  | StateType.Conditions.Validators
-  | StateType.Conditions.Prefillers
-  | StateType.Conditions.Sections
-  | any[];
-
-const conditionValueSelectorsEnum: Record<string, (...args: any[]) => any> = {
-  options: selectOptionConditionValue,
-  variables: selectVariableConditionValue,
-  documents: selectDocumentConditionValue,
-  prefillers: selectPrefillerConditionValue,
-  optionValidator: selectOptionValidatorConditionValue,
-  variableValidator: selectVariableValidatorConditionValue,
-};
-
-const conditionObjectSelectorsEnum: Record<string, (...args: any[]) => any> = {
-  options: selectOptionConditionsObject,
-  variables: selectVariableConditionsObject,
-  documents: selectDocumentConditionsObject,
-  prefillers: selectPrefillerConditionsObject,
-  optionValidator: selectOptionValidatorConditionsObject,
-  variableValidator: selectVariableValidatorConditionsObject,
-};
-
-const updateDispatchActionsEnum: Record<string, (...args: any[]) => any> = {
-  options: updateOptionConditionsAction,
-  variables: updateVariableConditionsAction,
-  documents: updateDocumentConditionsAction,
-  prefillers: updatePrefillersConditionsAction,
-  optionValidator: updateOptionValidatorConditionsAction,
-  variableValidator: updateVariableValidatorConditionsAction,
-};
-
-export class ConditionsRunner {
-  dispatch: Dispatch;
-
-  constructor(dispatch: Dispatch) {
-    this.dispatch = dispatch;
-  }
-
-  shouldConditionUpdate(
-    oldCondition: AllConditions,
-    newCondition: AllConditions
-  ) {
-    let update = false;
-    if (Array.isArray(oldCondition) && Array.isArray(newCondition)) {
-      oldCondition.forEach((value, index) => {
-        if (Array.isArray(value)) {
-          update =
-            update || this.shouldConditionUpdate(value, newCondition[index]);
-        } else {
-          update = update || value !== newCondition[index];
-        }
-      });
-    } else {
-      update = oldCondition !== newCondition;
-    }
-
-    return update;
-  }
-
-  isOptionRelatedToOption(optionA: number, optionB: number): boolean {
-    // Getting B relations
-    const OptionBParents = selectOptionParents(optionB);
-    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
-    const OptionBRootRelations = OptionBRoot
-      ? selectOptionRelations(OptionBRoot)
-      : undefined;
-
-    // Checking if B option is related to the option that changed
-    if (OptionBRootRelations) {
-      if (
-        optionA === optionB ||
-        OptionBRootRelations.children.options.includes(optionA) ||
-        OptionBRootRelations.dependants.includes(optionA)
-      ) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  isVariableRelatedToOption(variableId: number, optionId: number): boolean {
-    // Variable parent
-    const variableParentId = selectVariableParents(variableId)[0];
-
-    // Getting B relations
-    const optionParents = selectOptionParents(variableParentId);
-    const optionRoot =
-      optionParents.length > 0
-        ? optionParents[optionParents.length - 1]
-        : variableParentId;
-    const optionRootRelations = optionRoot
-      ? selectOptionRelations(optionRoot)
-      : undefined;
-
-    // Checking if B option is related to the option that changed
-    if (optionRootRelations) {
-      if (
-        optionRootRelations.children.options.includes(optionId) ||
-        optionRootRelations.dependants.includes(optionId)
-      ) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  isVariableRelatedToVariable(variableA: number, variableB: number): boolean {
-    // Getting variables options
-    const optionA = selectVariableParents(variableA)[0];
-    const optionB = selectVariableParents(variableB)[0];
-
-    // Getting B relations
-    const OptionBParents = selectOptionParents(optionB);
-    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
-    const OptionBRootRelations = OptionBRoot
-      ? selectOptionRelations(OptionBRoot)
-      : undefined;
-
-    // Checking if B option is related to the option that changed
-    if (OptionBRootRelations) {
-      if (
-        optionA === optionB ||
-        OptionBRootRelations.children.options.includes(optionA) ||
-        OptionBRootRelations.dependants.includes(optionA)
-      ) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Return's real option inputs, in case option is child of a repeated
-   * it returns the inputs of the repeatOption
-   * @param optionId Option ID
-   */
-  getInputsForOption(optionId: number) {
-    let inputId = optionId;
-    const optionReference = selectOptionReference(optionId);
-    const optionParents = selectOptionParents(optionId);
-    if (optionParents.length > 0) {
-      const parentReference = selectOptionReference(optionParents[0]);
-      if (
-        parentReference.meta.type === "repeated" &&
-        parentReference.meta.repeatOption !== undefined
-      ) {
-        inputId = parentReference.meta.repeatOption;
-      }
-    } else if (
-      optionReference.meta.type === "repeated" &&
-      optionReference.meta.repeatOption !== undefined
-    ) {
-      inputId = optionReference.meta.repeatOption;
-    }
-
-    return selectOptionInput(inputId).map(
-      (input, currentIndex) => currentIndex
-    );
-  }
-
-  /**
-   * Return's real vriables inputs, in case variable is child of a multiple
-   * it returns the inputs of the repeatOption
-   * @param variableId Variable ID
-   */
-  getInputsForVariable(variableId: number) {
-    const optionId = selectVariableParents(variableId)[0];
-    let inputId = optionId;
-    const optionParents = selectOptionParents(optionId);
-    if (optionParents.length > 0) {
-      const parentReference = selectOptionReference(optionParents[0]);
-      if (
-        parentReference.meta.type === "repeated" &&
-        parentReference.meta.repeatOption !== undefined
-      ) {
-        inputId = parentReference.meta.repeatOption;
-      }
-    }
-
-    return selectOptionInput(inputId).map(
-      (input, currentIndex) => currentIndex
-    );
-  }
-
-  executeHooks(
-    type: "variables" | "options" | "sections",
-    id: number,
-    index: number
-  ) {
-    let hooks:
-      | StateType.References.Relations.Options
-      | StateType.References.Relations.Variables
-      | StateType.References.Relations.Sections;
-    switch (type) {
-      case "options":
-        hooks = selectOptionRelations(id);
-        break;
-      case "variables":
-        hooks = selectVariableRelations(id);
-        break;
-      case "sections":
-        hooks = selectSectionRelations(id);
-        break;
-      default:
-        throw new Error(`Unkown hook type ${type}`);
-    }
-
-    type SubTypeTypes =
-      | "options"
-      | "variables"
-      | "sections"
-      | "prefillers"
-      | "optionValidator"
-      | "variableValidator"
-      | "documents";
-
-    const subTypesList: SubTypeTypes[] = [
-      "options",
-      "variables",
-      "sections",
-      "prefillers",
-      "optionValidator",
-      "variableValidator",
-      "documents",
-    ];
-
-    subTypesList.forEach((subType) => {
-      if (subType === "sections") {
-        return this.executeSectionsHooks(hooks, index);
-      }
-      let currentHooks: any[];
-
-      // Validators hooks
-      if (subType === "optionValidator" || subType === "variableValidator") {
-        currentHooks =
-          hooks.validators[
-            subType === "optionValidator" ? "options" : "variables"
-          ];
-      } else {
-        currentHooks = hooks[subType];
-      }
-
-      // Executing hooks conditions
-      currentHooks.forEach((currentId: number) => {
-        const execId = subType === "documents" ? 0 : currentId;
-        const updateId = subType === "documents" ? currentId : currentId;
-
-        // Update indexes
-        let execIndexes: number[] = [];
-
-        if (
-          ["options", "optionValidator"].includes(subType) &&
-          typeof updateId === "number"
-        ) {
-          if (
-            type === "options" &&
-            this.isOptionRelatedToOption(updateId, id)
-          ) {
-            execIndexes = [index];
-          } else if (
-            type === "variables" &&
-            this.isVariableRelatedToOption(id, updateId)
-          ) {
-            execIndexes = [index];
-          } else {
-            execIndexes = this.getInputsForOption(updateId);
-          }
-        } else if (
-          ["variables", "prefillers", "variableValidator"].includes(subType) &&
-          typeof updateId === "number"
-        ) {
-          if (
-            type === "options" &&
-            this.isVariableRelatedToOption(updateId, id)
-          ) {
-            execIndexes = [index];
-          } else if (
-            type === "variables" &&
-            this.isVariableRelatedToVariable(id, updateId)
-          ) {
-            execIndexes = [index];
-          } else {
-            execIndexes = this.getInputsForVariable(updateId);
-          }
-        } else {
-          execIndexes = [0];
-        }
-
-        // When we're executing an update on an option or an optionValidator,
-        // we need to make sure it is related to the hook to execute the same index
-        for (let i = 0; i < execIndexes.length; i += 1) {
-          // Getting the condition object
-          const condition = conditionObjectSelectorsEnum[subType](currentId);
-          const newCondition = this.executeCondition(
-            condition,
-            execId,
-            execIndexes[i],
-            subType
-          );
-
-          // Current condition
-          const oldCondition = conditionValueSelectorsEnum[subType](
-            currentId,
-            execIndexes[i]
-          );
-
-          if (this.shouldConditionUpdate(oldCondition, newCondition)) {
-            this.dispatch(
-              updateDispatchActionsEnum[subType](
-                updateId,
-                execIndexes[i],
-                newCondition
-              )
-            );
-          }
-        }
-      });
-
-      return null;
-    });
-  }
-
-  executeSectionsHooks(hooks: any, index: number) {
-    // Executing hooks conditions
-    Object.keys(hooks.sections).forEach((currentDocument: string) => {
-      hooks.sections[currentDocument].forEach((currentId: string) => {
-        // Getting the condition object
-        const condition = selectSectionConditionsObject(
-          parseInt(currentId, 10),
-          currentDocument
-        );
-        const newCondition = this.executeCondition(
-          condition,
-          parseInt(currentId, 10),
-          index,
-          "sections"
-        );
-
-        // Current condition
-        const oldCondition: any = selectSectionConditionValue(
-          parseInt(currentId, 10),
-          currentDocument
-        );
-        if (this.shouldConditionUpdate(oldCondition, newCondition)) {
-          this.dispatch(
-            updateSectionConditionsAction(
-              parseInt(currentId, 10),
-              currentDocument,
-              newCondition
-            )
-          );
-        }
-      });
-    });
-  }
-
-  executeCondition(
-    condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[],
-    id: number,
-    index: number,
-    conditionType: string
-  ): any {
-    if (Array.isArray(condition))
-      return condition.map((_condition) =>
-        this.executeCondition(_condition, id, index, conditionType)
-      );
-
-    // Returning true of condition is empty
-    if (
-      !(
-        typeof condition === "object" &&
-        typeof condition.conditions === "object" &&
-        Object.keys(condition.conditions).length > 0
-      )
-    )
-      return true;
-
-    // Populating Data
-    let currentData;
-    if (conditionType === "options" || conditionType === "optionValidator") {
-      currentData = new DataPopulator(condition.dataMap, id, index).getData();
-    } else if (
-      conditionType === "variables" ||
-      conditionType === "prefillers" ||
-      conditionType === "variableValidator"
-    ) {
-      const dataId = selectVariableParents(id)[0];
-      currentData = new DataPopulator(
-        condition.dataMap,
-        dataId,
-        index
-      ).getData();
-    } else if (
-      conditionType === "sections" ||
-      conditionType === "documents" ||
-      conditionType === "raw"
-    ) {
-      currentData = new DataPopulator(condition.dataMap).getData();
-    }
-    return LpLogic(condition.conditions, currentData);
-  }
-
-  executeRawCondition(condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[]) {
-    return this.executeCondition(condition, 0, 0, "raw");
-  }
-}