@legalplace/prerenderx 3.0.0 → 3.2.0

package/src/libs/DataPopulator.ts

@@ -1,304 +0,0 @@
-import { Types } from '@legalplace/referencesparser'
-import ConditionsRunner from './ConditionsRunner'
-
-type OVC_TYPE = {
-  options: {
-    [key: string]: boolean[]
-  }
-  variables: {
-    [key: string]: (number | string)[]
-  }
-}
-
-class DataPopulator {
-  private references: Types.ReferencesType
-
-  private ovc: OVC_TYPE
-
-  private conditionsRunner: ConditionsRunner
-
-  private id?: number
-
-  private index?: number
-
-  private dataMap: ConditionDataMap
-
-  private data: ConditionData = {
-    o: {},
-    v: {},
-    c: {
-      o: {},
-      s: {},
-      v: {}
-    }
-  }
-
-  constructor(conditionsRunner: ConditionsRunner, references: Types.ReferencesType, ovc: OVC_TYPE, dataMap: ConditionDataMap, id?: number, index?: number) {
-    this.id = id
-    this.ovc = ovc
-    this.index = index
-    this.dataMap = dataMap
-    this.references = references
-    this.conditionsRunner = conditionsRunner
-
-    // 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 = this.sectionConditionValue(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 = this.optionConditionValue(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 = this.references.relations.options[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 = this.variableConditionValue(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 = this.references.relations.options[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 = this.references.variables[variableId]
-      let values = this.getVariableValues(variableId)
-
-      const parseNumber = (v: string) => {
-        const result = parseFloat(v)
-        return Number.isNaN(result) ? '' : result
-      }
-      // If variable is of type number
-      if (variableReference.type === 'number') {
-        values = values.map(v => (typeof v === 'number' ? v : parseNumber(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 = this.ovc.variables[variableId]
-    if (this.id === undefined || this.index === undefined) {
-      return value
-    }
-
-    // Getting variable parent option
-    const variableRootParent = this.getVariableRootParent(variableId)
-    const variableRootRelations = this.references.relations.options[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 = this.references.relations.variables[variableId].parents
-    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 = this.ovc.options[optionId]
-    if (this.id === undefined || this.index === undefined) {
-      return inputs
-    }
-
-    // Getting variable parent option
-    const optionRootParent = this.getOptionRootParent(optionId)
-    const optionRootRelations = this.references.relations.options[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 = this.references.relations.options[optionId].parents
-    return optionParents.length > 0 ? optionParents[optionParents.length - 1] : optionId
-  }
-
-  /**
-   * Calculates option's condition
-   */
-  private optionConditionValue(optionId: number) {
-    // Getting option conditions
-    const conditions = this.references.conditions.options[optionId]
-    if (conditions === undefined) return undefined
-
-    // Getting option inputs length
-    const inputs = this.ovc.options[optionId]
-
-    return inputs.map((input, index) => {
-      return this.conditionsRunner.executeCondition(conditions, optionId, index, 'options')
-    })
-  }
-
-  /**
-   * Calculates variable's condition
-   */
-  private variableConditionValue(variableId: number) {
-    // Getting variable conditions
-    const conditions = this.references.conditions.variables[variableId]
-    if (conditions === undefined) return undefined
-
-    // Getting variable inputs length
-    const inputs = this.ovc.variables[variableId]
-
-    const result = inputs.map((input, index) => {
-      return this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables')
-    })
-
-    return result
-  }
-
-  /**
-   * Calculates section's condition
-   */
-  private sectionConditionValue(sectionId: number) {
-    // Getting section conditions
-    const conditions = this.references.conditions.sections.main[sectionId]
-    if (conditions === undefined) return undefined
-
-    return this.conditionsRunner.executeCondition(conditions, 0, 0, 'sections')
-  }
-}
-
-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/OvcConverter.ts

@@ -1,187 +0,0 @@
-import OVC_TYPE from './ovc.type'
-import { Types } from '@legalplace/referencesparser'
-
-export interface OldOVC {
-  o: {
-    [k: string]: string | number | (string | number)[]
-  }
-  v: {
-    [k: string]: string | number | (string | number)[]
-  }
-  c: {
-    [k: string]: boolean | boolean[]
-  }
-}
-
-class OvcConverter {
-  public convertToOptionsVariables(
-    ovc: OldOVC,
-    references: Types.ReferencesType
-  ) {
-    const inputs: OVC_TYPE = {
-      options: {},
-      variables: {}
-    }
-
-if (typeof ovc !== 'object') return inputs;
-
-    // Reading options
-    if (typeof ovc.o === 'object') {
-      Object.keys(ovc.o).forEach(id => {
-        const currentOption = ovc.o[id];
-
-        // If it's a multiple
-        if (Array.isArray(currentOption)) {
-          const occurences = currentOption.length;
-          // Adding static childrens
-          inputs.options = {
-            ...inputs.options,
-            ...this.pushStaticChildren(
-              inputs.options,
-              id,
-              occurences,
-              references
-            )
-          };
-          currentOption.forEach((childId, index) => {
-            const sanitizedId =
-              typeof childId === 'string' && childId.split('_').length > 0
-                ? childId.split('_')[0]
-                : childId;
-
-            // Making sure the input exist
-            if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
-              inputs.options[id] = new Array(occurences).fill(false);
-            }
-
-            // Making sure the childId is not empty
-            if (
-              typeof sanitizedId === 'string' &&
-              sanitizedId.trim().length === 0
-            ) {
-              return;
-            }
-
-            // Creating input if it doesn't exist
-            if (
-              !Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)
-            ) {
-              inputs.options[sanitizedId] = new Array(occurences).fill(false);
-            }
-
-            // Adding static childrens
-            inputs.options = {
-              ...inputs.options,
-              ...this.pushStaticChildren(
-                inputs.options,
-                sanitizedId,
-                occurences,
-                references
-              )
-            };
-
-            // Setting current index to true
-            inputs.options[sanitizedId][index] = true;
-          });
-        } else {
-          if (
-            typeof currentOption === 'string' &&
-            currentOption.trim().length === 0
-          )
-            return;
-          inputs.options[currentOption] = [true];
-        }
-      });
-    }
-
-    // Reading checkboxes
-    if (typeof ovc.c === 'object') {
-      Object.keys(ovc.c).forEach(id => {
-        const currentCheckbox = ovc.c[id];
-        if (typeof id === 'string' && id.trim().length === 0) return;
-        // If it's a multiple
-        if (Array.isArray(currentCheckbox)) {
-          inputs.options[id] = currentCheckbox;
-        } else {
-          inputs.options[id] = [currentCheckbox];
-        }
-      });
-    }
-
-    // Reading variables
-    if (typeof ovc.v === 'object') {
-      Object.keys(ovc.v).forEach(id => {
-        const currentVariable = ovc.v[id];
-
-        // If it's a multiple
-        if (Array.isArray(currentVariable)) {
-          inputs.variables[id] = currentVariable;
-          // Getting parentsTree & parent id
-          const parentsTree = references.relations.variables[id].parents;
-          const parentOption =
-            inputs.options[`${parentsTree[parentsTree.length - 1]}`];
-          if (Array.isArray(parentOption)) {
-            const occurences = parentOption.length;
-            if (currentVariable.length < occurences) {
-              inputs.variables[id] = [
-                ...currentVariable,
-                ...Array(occurences - currentVariable.length).fill('')
-              ];
-            }
-          }
-        } else {
-          inputs.variables[id] = [currentVariable];
-        }
-      });
-    }
-
-    return inputs;
-  }
-
-  public isOvc(_obj: OVC_TYPE | OldOVC): _obj is OldOVC {
-    if (typeof _obj !== 'object' || _obj === null) return false
-    const ovcKeys = ['o', 'v', 'c']
-    const foundKeys = Object.keys(_obj)
-      .map((key): number => (ovcKeys.includes(key) ? 1 : 0))
-      .reduce((a, b) => a + b, 0)
-    return foundKeys > 1
-  }
-
-  public isOptionsVariables(_obj: OVC_TYPE | OldOVC) {
-    if (typeof _obj !== 'object' || _obj === null) return false
-    const optionsVariablesKeys = ['options', 'variables']
-    const foundKeys = Object.keys(_obj)
-      .map((key): number => (optionsVariablesKeys.includes(key) ? 1 : 0))
-      .reduce((a, b) => a + b, 0)
-    return foundKeys === 2
-  }
-
-    private pushStaticChildren(
-    inputOptions: OVC_TYPE['options'],
-    id: number | string,
-    occurences: number,
-    references: Types.ReferencesType
-  ) {
-    const result = { ...inputOptions };
-    const intId = typeof id === 'number' ? id : parseInt(id, 10);
-
-    // Getting children options and variables
-    const { options } = references.relations.options[intId].children;
-
-    // Getting static children
-    const staticOptions = options.filter(childId => {
-      return references.options[childId].meta.type === 'static';
-    });
-
-    staticOptions.forEach(childId => {
-      // Creating input if it doesn't exist
-      if (!Object.prototype.hasOwnProperty.call(result, childId)) {
-        result[childId] = new Array(occurences).fill(false);
-      }
-    });
-
-    return result;
-  }
-}
-
-export default new OvcConverter()

package/src/libs/ovc.type.ts

@@ -1,10 +0,0 @@
-type OVC_TYPE = {
-  options: {
-    [key: string]: boolean[]
-  }
-  variables: {
-    [key: string]: (number | string)[]
-  }
-}
-
-export default OVC_TYPE