@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/DocumentsOutputs.ts

@@ -0,0 +1,171 @@
+import type {
+  SectionV3,
+  OptionV3,
+  VariableV3,
+} from '@legalplace/models-v3-types';
+import type {
+  ReferencesSingleOutputType,
+  ReferencesSectionsDocumentType,
+} from '@legalplace/referencesparser/dist/libs/References.type';
+import { NumAuto } from './NumAuto';
+import {
+  getRelatedVariablesValues,
+  parseOutputWithVariables,
+} from '../helpers/outputsParsing';
+
+export interface GettersType {
+  // References
+  optionReference: (id: number) => Readonly<OptionV3>;
+  outputReference: (
+    id: number
+  ) => Readonly<ReferencesSingleOutputType> | undefined;
+  variableReference: (id: number) => Readonly<VariableV3>;
+  sectionReference: (id: number) => Readonly<SectionV3>;
+  documentSections: (
+    document: string
+  ) => Readonly<ReferencesSectionsDocumentType> | undefined;
+
+  // Inputs
+  optionInputs: (id: number) => Readonly<boolean[]>;
+  variablesInputs: (id: number) => Readonly<(string | number)[]>;
+
+  // Conditions
+  optionConditions: (
+    id: number,
+    index: number
+  ) => Readonly<boolean | undefined>;
+  sectionConditions: (
+    id: number,
+    document: string
+  ) => Readonly<boolean | undefined>;
+}
+
+export class DocumentsOutputs {
+  private getters: GettersType;
+
+  private documentSections: Readonly<ReferencesSectionsDocumentType> = {};
+
+  private document: string;
+
+  private outputs: Record<string, string> = {};
+
+  constructor(getters: GettersType, document: string) {
+    this.getters = getters;
+    this.document = document;
+    const documentSections = getters.documentSections(document);
+    if (documentSections === undefined) return;
+    this.documentSections = documentSections;
+
+    // Resetting Numauto
+    NumAuto.resetNums();
+
+    // Looping throught sections
+    this.loopThroughtSections();
+  }
+
+  public getOutputs() {
+    return this.outputs;
+  }
+
+  private loopThroughtSections() {
+    Object.keys(this.documentSections).forEach((sectionId) => {
+      const section = this.documentSections[sectionId];
+      this.parseSection(section);
+    });
+  }
+
+  private parseSection(section: SectionV3) {
+    section.options.forEach((option) => {
+      this.parseOption(option);
+    });
+  }
+
+  private parseOption(id: number): void {
+    const option = this.getters.optionReference(id);
+    if (!['hidden', 'repeated'].includes(option.meta.type)) return;
+
+    // If it's a repeated
+    if (option.meta.type === 'repeated') this.parseRepeated(option);
+    else this.parseHidden(option);
+  }
+
+  private parseRepeated(option: OptionV3): void {
+    const { id, repeatOption } = option.meta;
+
+    if (repeatOption === undefined)
+      throw new Error(`Repeated option ${id} is not linked to any multiple`);
+
+    // Getting inputs
+    const inputs = this.getters.optionInputs(repeatOption);
+    inputs.forEach((input, index) => {
+      // Getting condition
+      const condition = this.getters.optionConditions(repeatOption, index);
+
+      // If condition or input are false, we stop here
+      if (condition === false || input === false) return;
+
+      // Parsing self
+      this.parseHidden(option, index, true, inputs.length);
+
+      // Parsing children
+      option.options.forEach((childId) => {
+        const childOption = this.getters.optionReference(childId);
+        this.parseHidden(childOption, index, true, inputs.length);
+      });
+    });
+  }
+
+  private parseHidden(
+    option: OptionV3,
+    index = 0,
+    forcedTruthyInput = false,
+    siblingsCount = 0
+  ): void {
+    const { id } = option.meta;
+    const outputReference = this.getters.outputReference(id);
+    if (outputReference === undefined) return;
+
+    if (outputReference.raw.trim().length === 0) return;
+
+    // Input
+    const input =
+      forcedTruthyInput === true ? true : this.getters.optionInputs(id)[index];
+
+    // Condition
+    const condition = this.getters.optionConditions(id, index);
+
+    // If condition or input are false, we stop here
+    if (condition === false || input === false) return;
+
+    // Parsing output with related variables
+    const variables = getRelatedVariablesValues(
+      id,
+      index,
+      outputReference.variables
+    );
+
+    // Autonums
+    const autonums: [string, string, number, string | null][] =
+      outputReference.autonums.map((currentAn) => {
+        const [type, catalog, tag] = currentAn;
+
+        const currentNum =
+          type === 'numauto-pre'
+            ? NumAuto.getNumPre(catalog, index, siblingsCount)
+            : NumAuto.getNum(catalog, tag);
+
+        return [type, catalog, currentNum, tag];
+      });
+
+    const output = parseOutputWithVariables(
+      outputReference.raw,
+      id,
+      index,
+      variables,
+      autonums
+    );
+
+    const key = `output-${id}-${index}`;
+    this.outputs[key] = output;
+  }
+}

package/src/libs/Eval/EvalBase.ts

@@ -0,0 +1,116 @@
+import {
+  selectVariableInputByIndex,
+  selectVariableInput,
+} from '../../redux/selectors/inputs';
+import {
+  areVariablesSiblings,
+  selectVariableReference,
+} from '../../redux/selectors/references';
+import { selectIsVariableDisplayed } from '../../redux/selectors/conditions';
+
+export class EvalBase {
+  index: number;
+
+  id: number;
+
+  doNotEvaluate = false;
+
+  isDisplay = false;
+
+  constructor(id: number, index: number) {
+    this.id = id;
+    this.index = index;
+  }
+
+  /**
+   * Returns a variable value from variable tag [var:ID]
+   * @param varRef Variable tag [var: ID]
+   * @param full Whether return all values or current index's value (or index 0 if no siblings found)
+   */
+  getVariableValue(varRef: string | number, full?: true): (string | number)[];
+
+  getVariableValue(varRef: string | number, full?: false): string | number;
+
+  getVariableValue(varRef: string | number, full = false) {
+    let variableId: number;
+    if (typeof varRef === 'number' || varRef.match(/^([0-9]+)$/))
+      variableId = typeof varRef === 'number' ? varRef : parseInt(varRef, 10);
+    else {
+      const matchId = varRef.match(/([0-9]+)/);
+      if (matchId === null) return full === true ? [''] : '';
+
+      variableId = parseInt(matchId[0], 10);
+    }
+    const index = areVariablesSiblings(variableId, this.id) ? this.index : 0;
+
+    // Checking if variable is displayed
+    let value;
+    if (full === false) {
+      value = selectVariableInputByIndex(variableId, index);
+      if (selectIsVariableDisplayed(variableId, index) === false) return '';
+      return this.parseNumber(value);
+    }
+
+    value = selectVariableInput(variableId);
+    // Replacing all non displayed values with empty strings
+    value = value.map((v, i) =>
+      selectIsVariableDisplayed(variableId, i) === true
+        ? this.parseNumber(v)
+        : ''
+    );
+    return value;
+  }
+
+  parseNumber(value: string | number) {
+    if (typeof value === 'number') return value;
+
+    // If it's a display evaluation (D=) we keep values starting by 0 as strings
+    if (this.isDisplay && typeof value === 'string' && /^0/.test(value.trim()))
+      return value;
+
+    // Otherwise we convert values to float numbers and make
+    // sure to replace commas by dots
+    if (/^([0-9,.]+)$/.test(value.trim()))
+      return parseFloat(value.replace(',', '.').trim());
+    return value;
+  }
+
+  setEmpty(value: string | number, replacer: string | number) {
+    return typeof value === 'string'
+      ? value.replace(
+          /___EMPTY___/g,
+          typeof replacer === 'string' ? replacer : replacer.toString()
+        )
+      : value;
+  }
+
+  setCommas(value: string | number) {
+    const stringValue = typeof value === 'number' ? value.toString() : value;
+
+    return /^([0-9,.]+)$/.test(stringValue.trim())
+      ? stringValue.replace('.', ',').trim()
+      : value;
+  }
+
+  isVariableEditable(varRef: string | number) {
+    let variableId: number;
+    if (typeof varRef === 'number' || varRef.match(/^([0-9]+)$/))
+      variableId = typeof varRef === 'number' ? varRef : parseInt(varRef, 10);
+    else {
+      const matchId = varRef.match(/([0-9]+)/);
+      if (matchId === null) return false;
+
+      variableId = parseInt(matchId[0], 10);
+    }
+
+    // Variable Reference
+    const variable = selectVariableReference(variableId);
+
+    // Getting index
+    const index = areVariablesSiblings(variableId, this.id) ? this.index : 0;
+
+    return (
+      variable.hidden !== true && selectIsVariableDisplayed(variableId, index)
+    );
+  }
+}