@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/Eval/NumbersToLetters.ts

@@ -0,0 +1,185 @@
+/**
+ * NumberToLetter
+ * --------------
+ * Converts numbers to letters, original code was written by GALA OUSSE Brice
+ * https://github.com/hbendalibraham/number-to-letters/blob/master/nombre_en_lettre.js
+ * --------------
+ * Library was rewritten in order to add typescript support and to handle errors with
+ * throws instead of simple string returns
+ */
+export class NumberToLetter {
+  static French(
+    number: string | number,
+    units: string | false = false,
+    decimals: string | false = false
+  ): string {
+    const letter: Record<number, string> = {
+      0: 'zéro',
+      1: 'un',
+      2: 'deux',
+      3: 'trois',
+      4: 'quatre',
+      5: 'cinq',
+      6: 'six',
+      7: 'sept',
+      8: 'huit',
+      9: 'neuf',
+      10: 'dix',
+      11: 'onze',
+      12: 'douze',
+      13: 'treize',
+      14: 'quatorze',
+      15: 'quinze',
+      16: 'seize',
+      17: 'dix-sept',
+      18: 'dix-huit',
+      19: 'dix-neuf',
+      20: 'vingt',
+      30: 'trente',
+      40: 'quarante',
+      50: 'cinquante',
+      60: 'soixante',
+      70: 'soixante-dix',
+      80: 'quatre-vingt',
+      90: 'quatre-vingt-dix',
+    };
+
+    let quotient;
+    let left;
+    let numberToLetter = '';
+
+    // Validating number before proceeding
+    if (number.toString().replace(/ /gi, '').length > 15)
+      throw new Error('Capacity overrun');
+    if (Number.isNaN(number.toString().replace(/ /gi, '')))
+      throw new Error('Unvalid number');
+
+    // Parsing number
+    const nb = parseFloat(number.toString().replace(/ /gi, ''));
+
+    // Handling commas
+    if (Math.ceil(nb) !== nb) {
+      const [wholeNumberPart, decimalPart] = number.toString().split('.');
+      const decimalNumber = decimalPart?.startsWith('0')
+        ? Array.from(decimalPart)
+            .map((decimal) => this.French(decimal))
+            .join(' ')
+        : this.French(decimalPart);
+      return (
+        this.French(wholeNumberPart) +
+        (units ? ` ${units} et ` : ' virgule ') +
+        decimalNumber +
+        (decimals ? ` ${decimals}` : '')
+      );
+    }
+
+    /**
+     * Converting number to letters
+     */
+    const numberLength = nb.toString().length;
+    switch (numberLength) {
+      case 1:
+        numberToLetter = letter[nb];
+        break;
+      case 2:
+        if (nb > 19) {
+          quotient = Math.floor(nb / 10);
+          left = nb % 10;
+          if (nb < 71 || (nb > 79 && nb < 91)) {
+            if (left === 0) numberToLetter = letter[quotient * 10];
+            if (left === 1)
+              numberToLetter = `${letter[quotient * 10]}-et-${letter[left]}`;
+            if (left > 1)
+              numberToLetter = `${letter[quotient * 10]}-${letter[left]}`;
+          } else
+            numberToLetter = `${letter[(quotient - 1) * 10]}-${
+              letter[10 + left]
+            }`;
+        } else numberToLetter = letter[nb];
+        break;
+      case 3:
+        quotient = Math.floor(nb / 100);
+        left = nb % 100;
+        if (quotient === 1 && left === 0) numberToLetter = 'cent';
+        if (quotient === 1 && left !== 0)
+          numberToLetter = `cent ${this.French(left)}`;
+        if (quotient > 1 && left === 0)
+          numberToLetter = `${letter[quotient]} cents`;
+        if (quotient > 1 && left !== 0)
+          numberToLetter = `${letter[quotient]} cent ${this.French(left)}`;
+        break;
+      case 4:
+      case 5:
+      case 6:
+        quotient = Math.floor(nb / 1000);
+        left = nb - quotient * 1000;
+        if (quotient === 1 && left === 0) numberToLetter = 'mille';
+        if (quotient === 1 && left !== 0)
+          numberToLetter = `mille ${this.French(left)}`;
+        if (quotient > 1 && left === 0)
+          numberToLetter = `${this.French(quotient)} mille`;
+        if (quotient > 1 && left !== 0)
+          numberToLetter = `${this.French(quotient)} mille ${this.French(
+            left
+          )}`;
+        break;
+      case 7:
+      case 8:
+      case 9:
+        quotient = Math.floor(nb / 1000000);
+        left = nb % 1000000;
+        if (quotient === 1 && left === 0) numberToLetter = 'un million';
+        if (quotient === 1 && left !== 0)
+          numberToLetter = `un million ${this.French(left)}`;
+        if (quotient > 1 && left === 0)
+          numberToLetter = `${this.French(quotient)} millions`;
+        if (quotient > 1 && left !== 0)
+          numberToLetter = `${this.French(quotient)} millions ${this.French(
+            left
+          )}`;
+        break;
+      case 10:
+      case 11:
+      case 12:
+        quotient = Math.floor(nb / 1000000000);
+        left = nb - quotient * 1000000000;
+        if (quotient === 1 && left === 0) numberToLetter = 'un milliard';
+        if (quotient === 1 && left !== 0)
+          numberToLetter = `un milliard ${this.French(left)}`;
+        if (quotient > 1 && left === 0)
+          numberToLetter = `${this.French(quotient)} milliards`;
+        if (quotient > 1 && left !== 0)
+          numberToLetter = `${this.French(quotient)} milliards ${this.French(
+            left
+          )}`;
+        break;
+      case 13:
+      case 14:
+      case 15:
+        quotient = Math.floor(nb / 1000000000000);
+        left = nb - quotient * 1000000000000;
+        if (quotient === 1 && left === 0) numberToLetter = 'un billion';
+        if (quotient === 1 && left !== 0)
+          numberToLetter = `un billion ${this.French(left)}`;
+        if (quotient > 1 && left === 0)
+          numberToLetter = `${this.French(quotient)} billions`;
+        if (quotient > 1 && left !== 0)
+          numberToLetter = `${this.French(quotient)} billions ${this.French(
+            left
+          )}`;
+        break;
+      default:
+        throw new Error(`Capacity overrun`);
+    }
+
+    if (
+      numberToLetter.substr(
+        numberToLetter.length - 'quatre-vingt'.length,
+        'quatre-vingt'.length
+      ) === 'quatre-vingt'
+    )
+      numberToLetter += 's';
+
+    return numberToLetter;
+  }
+}

package/src/libs/EvalVariable.ts

@@ -0,0 +1,262 @@
+import type { VariableV3 } from '@legalplace/models-v3-types';
+import { selectVariableReference } from '../redux/selectors/references';
+import { EvalFunctions } from './Eval/EvalFunctions';
+
+/**
+ * EvalVariable class
+ * ------------------
+ * Parses an eval variable's
+ * evaluation
+ */
+export class EvalVariable extends EvalFunctions {
+  variablesValues: Record<string, string | number> = {};
+
+  evaluation: string;
+
+  rawEvaluation: string;
+
+  result: string | number | null = null;
+
+  index: number;
+
+  hasFunctions = false;
+
+  abortEvaluation = false;
+
+  constructor(variable: VariableV3, index: number) {
+    super(variable.id, index);
+
+    this.evaluation =
+      typeof variable.eval?.formula === 'string' ? variable.eval?.formula : '0';
+    this.rawEvaluation = this.evaluation;
+    this.index = index;
+
+    // Setting isDisplay
+    if (/^D=(.*)/i.test(this.evaluation)) {
+      this.isDisplay = true;
+    }
+
+    // Compiling & executing functions
+    this.executeFunctions();
+
+    // Populating value
+    this.populateValues();
+
+    // Evaluating
+    this.evaluate();
+  }
+
+  /**
+   * Populates evaluation with the required variables
+   */
+  populateValues(): void {
+    let evalVariables = {};
+
+    // Extracting eval variables tags
+    const match = this.evaluation.match(/\[var:([0-9]+)\]/gi);
+    if (match !== null) {
+      // Tranforming tags into integer ids
+      const evalVariablesTags: string[] = [...match];
+      const evalVariablesIds = evalVariablesTags.map((current) => {
+        const matchId = current.match(/([0-9]+)/);
+        if (matchId === null) return 0;
+        return parseInt(matchId[0], 10);
+      });
+
+      // Getting values
+      evalVariablesIds.forEach((variableId) => {
+        let value = this.getVariableValue(variableId, false);
+        if (typeof value === 'string' && value.trim().length === 0) {
+          value = '___EMPTY___';
+
+          if (this.isVariableEditable(variableId)) this.abortEvaluation = true;
+        }
+        evalVariables = {
+          ...evalVariables,
+          [variableId]: value,
+        };
+      });
+    }
+
+    this.variablesValues = evalVariables;
+
+    let operation = `${this.evaluation}`;
+    Object.keys(this.variablesValues).forEach((variableId) => {
+      let value = this.variablesValues[variableId];
+      value = typeof value === 'number' ? value.toString() : value;
+      operation = operation.replace(
+        new RegExp(`\\[var:${variableId}\\]`, 'g'),
+        value
+      );
+    });
+
+    this.evaluation = operation;
+  }
+
+  /**
+   * Executes evaluation functions
+   */
+  executeFunctions(): void {
+    /**
+     * Functions list
+     */
+    const functionsList: Record<string, (...args: any[]) => string | number> = {
+      AFFICHER_DATE: this.afficherDate,
+      AFFICHER_ANNEE: this.afficherAnnee,
+      JOUR_OUVRE: this.jourOuvre,
+      JOUR_OUVRABLE: this.jourOuvrable,
+      DATE: this.date,
+      AJOUTER_JOURS_OUVRABLES: this.ajouterJoursOuvrables,
+      AJOUTER_JOURS_OUVRES: this.ajouterJoursOuvres,
+      AJOUTER_JOURS: this.ajouterJours,
+      AJOUTER_MOIS: this.ajouterMois,
+      AJOUTER_ANNEES: this.ajouterAnnees,
+      ENLEVER_JOURS_OUVRABLES: this.enleverJoursOuvrables,
+      ENLEVER_JOURS_OUVRES: this.enleverJoursOuvres,
+      ENLEVER_JOURS: this.enleverJours,
+      ENLEVER_MOIS: this.enleverMois,
+      ENLEVER_ANNEES: this.enleverAnnees,
+      DUREE_JOURS: this.dureeJours,
+      DUREE_MOIS: this.dureeMois,
+      DUREE_ANNEES: this.dureeAnnees,
+      TODAY: this.today,
+      SOMME: this.somme,
+      LETTRES: this.lettres,
+    };
+
+    /**
+     * Extracting and executing functions
+     */
+    const regex = /([a-z_]+)\(([^()]*)\)/gi;
+    let formulas = this.evaluation.match(regex);
+
+    // Keep the loop running until we detect no more functions
+    while (formulas && this.doNotEvaluate === false) {
+      formulas.forEach((formula) => {
+        const reg = new RegExp(regex, 'gi');
+        const extract = reg.exec(formula);
+        if (extract === null) return;
+
+        // Stopping evaluation right after a function detects an error
+        if (this.doNotEvaluate === true) return;
+
+        const functionName = extract[1];
+        const args = extract[2]
+          .split(extract[2].indexOf(';') > -1 ? ';' : ',')
+          .map((v) => v.trim());
+
+        let result = '';
+        if (Object.keys(functionsList).includes(functionName)) {
+          result = functionsList[functionName].apply(this, args).toString();
+          this.hasFunctions = true;
+        } else {
+          // eslint-disable-next-line no-console
+          console.error(
+            `Erreur de modélisation: la fonction %c"${functionName}" %cest inconnue dans la formule: ${this.rawEvaluation}`,
+            'font-weight: bold;',
+            'font-weight: initial'
+          );
+          this.doNotEvaluate = true;
+        }
+
+        this.evaluation = this.evaluation.replace(formula, result);
+      });
+
+      formulas = this.evaluation.match(regex);
+    }
+  }
+
+  /**
+   * Evaluates current evaluation
+   */
+  evaluate(): string | number {
+    // Stoping evaluation in case the functions processing decided so
+    if (this.doNotEvaluate === true) {
+      this.result = '';
+      return '';
+    }
+    if (
+      typeof this.evaluation !== 'string' ||
+      this.evaluation.trim().length === 0
+    ) {
+      this.result = '';
+      return '';
+    }
+
+    let result;
+    try {
+      // If result is a date returning it
+      if (/^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/.test(this.evaluation)) {
+        result = this.evaluation;
+      } else if (/^D=(.*)/i.test(this.evaluation)) {
+        result = this.setEmpty(this.evaluation.replace(/^D=/i, ''), '');
+      } else if (this.abortEvaluation === true) {
+        result = '';
+      } else {
+        const cleanEvaluation = this.setEmpty(this.evaluation, 0);
+        // eslint-disable-next-line no-eval
+        result = eval(
+          typeof cleanEvaluation === 'string'
+            ? cleanEvaluation
+            : cleanEvaluation.toString()
+        );
+        if (result === Infinity || Number.isNaN(result)) {
+          result = this.hasFunctions === true ? '' : 0;
+        }
+      }
+    } catch (e) {
+      result =
+        this.hasFunctions === true || this.abortEvaluation === true ? '' : 0;
+    }
+
+    // Rounding
+    if (typeof result === 'number') {
+      const variableReference = selectVariableReference(this.id);
+      if (variableReference?.eval === undefined)
+        throw new Error(`Variable ${this.id} does not exist`);
+      const { decimals, round } = variableReference.eval;
+      const evalDecimal =
+        (typeof decimals === 'number' && !Number.isNaN(decimals)) ||
+        typeof decimals === 'string'
+          ? decimals
+          : undefined;
+
+      // Decimals
+      let numberOfDecimals = 0;
+      if (evalDecimal !== undefined) {
+        numberOfDecimals =
+          typeof evalDecimal === 'string'
+            ? parseInt(evalDecimal, 10)
+            : evalDecimal;
+      }
+
+      // Decimals
+      let decma = 1;
+      for (let i = 0; i < numberOfDecimals; i += 1) decma *= 10;
+
+      // Rounding strategy
+      const rounders = {
+        round: Math.round,
+        ceil: Math.ceil,
+        floor: Math.floor,
+      };
+      if (round !== undefined && rounders[round]) {
+        if (evalDecimal !== undefined) {
+          result = rounders[round](result * decma) / decma;
+        } else {
+          result = rounders[round](result);
+        }
+      } else if (evalDecimal !== undefined) {
+        result = Math.round(result * decma) / decma;
+      }
+    }
+
+    if (result === undefined) {
+      this.result = '';
+      return '';
+    }
+
+    this.result = result.toString();
+    return result;
+  }
+}

package/src/libs/EventsTracking.ts

@@ -0,0 +1,241 @@
+import Globals from '../Globals';
+
+export type EventsPropsType = Record<
+  string,
+  string | number | boolean | Record<string, string | number | boolean>
+>;
+
+class _EventsTracking {
+  private initiated = false;
+
+  private queue: [string, any[]][] = [];
+
+  private queueTimer: ReturnType<typeof setTimeout> | null = null;
+
+  public track(eventName: string, eventProps?: EventsPropsType) {
+    if (!this.initiated) this.init();
+
+    // Mixpanel
+    this.trackMix(eventName, { ...eventProps });
+
+    // Facebook Pixel
+    this.trackFB(eventName, { ...eventProps });
+
+    // Google Analytics
+    this.trackGA(eventName, { ...eventProps });
+
+    // Sendinblue
+    this.trackSIB(eventName, { ...eventProps });
+  }
+
+  public register(props: EventsPropsType) {
+    if (!this.initiated) this.init();
+
+    // Mixpanel
+    this.registerMix(props);
+
+    // Facebook Pixel
+    this.registerFB(props);
+  }
+
+  public trigger(name: string) {
+    if (!this.initiated) this.init();
+
+    // Hotjar
+    this.triggerHj(name);
+  }
+
+  private init() {
+    this.initiated = true;
+    this.register({
+      'WizardX Build Commit':
+        process.env.REACT_APP_COMMIT || 'Unkown build commit',
+      Environement: Globals.env,
+      'Powered By': 'WizardX',
+    });
+    this.trigger('wizardx');
+  }
+
+  /**
+   * Executes events tracking queue
+   */
+  private executeQueue() {
+    for (let i = 0; i < this.queue.length; i += 1) {
+      const currentEvent = this.queue[i];
+      const args = [];
+      const [fnName] = currentEvent;
+      if (currentEvent.length > 1) {
+        for (let x = 0; x < currentEvent[1].length; x += 1)
+          args.push(currentEvent[1][x]);
+
+        args.push(true);
+
+        let fn: (...a: any) => any;
+
+        switch (fnName) {
+          case 'trackMix':
+            fn = this.trackMix.bind(this);
+            break;
+          case 'trackFB':
+            fn = this.trackFB.bind(this);
+            break;
+          case 'trackGA':
+            fn = this.trackGA.bind(this);
+            break;
+          case 'trackSIB':
+            fn = this.trackSIB.bind(this);
+            break;
+          case 'registerMix':
+            fn = this.registerMix.bind(this);
+            break;
+          case 'registerFB':
+            fn = this.registerFB.bind(this);
+            break;
+          case 'triggerHj':
+            fn = this.triggerHj.bind(this);
+            break;
+          default:
+            throw new Error(
+              `Unkown function "${fnName}" found on events tracking queue`
+            );
+        }
+
+        // Getting function
+        const result = fn(...args);
+        if (result === true) {
+          this.queue.splice(i, 1);
+        }
+      }
+    }
+  }
+
+  private queueTimeout() {
+    if (this.queueTimer !== null) clearTimeout(this.queueTimer);
+
+    this.queueTimer = setTimeout(() => {
+      this.executeQueue();
+    }, 500);
+  }
+
+  public trackMix(
+    eventName: string,
+    eventProps?: EventsPropsType,
+    doNotPushToQueue = false
+  ) {
+    if (!this.initiated) this.init();
+
+    if (typeof window.mixpanel !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.mixpanel.track(eventName, eventProps);
+      return true;
+    }
+
+    if (doNotPushToQueue === false)
+      this.queue.push(['trackMix', [eventName, eventProps]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  public trackSIB(
+    eventName: string,
+    eventProps?: EventsPropsType,
+    doNotPushToQueue = false
+  ) {
+    if (!this.initiated) this.init();
+
+    if (typeof window.sendinblue !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.sendinblue.track(eventName, eventProps);
+      return true;
+    }
+
+    if (doNotPushToQueue === false)
+      this.queue.push(['trackSIB', [eventName, eventProps]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  private trackFB(
+    eventName: string,
+    eventProps?: EventsPropsType,
+    doNotPushToQueue = false
+  ) {
+    if (typeof window.fbq !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.fbq('trackCustom', eventName, eventProps);
+      return true;
+    }
+
+    if (doNotPushToQueue === false)
+      this.queue.push(['trackFB', [eventName, eventProps]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  private trackGA(
+    eventName: string,
+    eventProps?: EventsPropsType,
+    doNotPushToQueue = false
+  ) {
+    if (typeof window.ga !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.ga(
+        'send',
+        'event',
+        'lpTracking',
+        'track',
+        eventName,
+        1,
+        eventProps
+      );
+      return true;
+    }
+
+    if (doNotPushToQueue === false)
+      this.queue.push(['trackGA', [eventName, eventProps]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  private registerMix(props: EventsPropsType, doNotPushToQueue = false) {
+    if (typeof window.mixpanel !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.mixpanel.register(props);
+      return true;
+    }
+    if (doNotPushToQueue === false) this.queue.push(['registerMix', [props]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  private registerFB(props: EventsPropsType, doNotPushToQueue = false) {
+    if (typeof window.fbq !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.fbq('trackCustom', 'GeneralProps', props);
+      return true;
+    }
+    if (doNotPushToQueue === false) this.queue.push(['registerFB', [props]]);
+
+    this.queueTimeout();
+    return false;
+  }
+
+  private triggerHj(name: string, doNotPushToQueue = false) {
+    if (typeof window.hj !== 'undefined') {
+      if (this.queue.length > 0 && !doNotPushToQueue) this.executeQueue();
+      window.hj('trigger', name);
+      return true;
+    }
+    if (doNotPushToQueue === false) this.queue.push(['triggerHj', [name]]);
+
+    this.queueTimeout();
+    return false;
+  }
+}
+
+export const EventsTracking = new _EventsTracking();