@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/libs/Eval/EvalFunctions.js

@@ -0,0 +1,480 @@
+import * as moment from 'moment-business-days';
+import { EvalBase } from './EvalBase';
+import { NumberToLetter } from './NumbersToLetters';
+let holidays = [];
+const frenchHolidays = (year) => {
+    const JourAn = new Date(year, 0, 1);
+    const FeteTravail = new Date(year, 4, 1);
+    const Victoire1945 = new Date(year, 4, 8);
+    const FeteNationale = new Date(year, 6, 14);
+    const Assomption = new Date(year, 7, 15);
+    const Toussaint = new Date(year, 10, 1);
+    const Armistice = new Date(year, 10, 11);
+    const Noel = new Date(year, 11, 25);
+    const MF = Math.floor;
+    const G = year % 19;
+    const C = MF(year / 100);
+    const H = (C - MF(C / 4) - MF((8 * C + 13) / 25) + 19 * G + 15) % 30;
+    const I = H - MF(H / 28) * (1 - MF(H / 28) * MF(29 / (H + 1)) * MF((21 - G) / 11));
+    const J = (year * 1 + MF(year / 4) + I + 2 - C + MF(C / 4)) % 7;
+    const L = I - J;
+    const MoisPaques = 3 + MF((L + 40) / 44);
+    const JourPaques = L + 28 - 31 * MF(MoisPaques / 4);
+    const LundiPaques = new Date(year, MoisPaques - 1, JourPaques + 1);
+    const Ascension = new Date(year, MoisPaques - 1, JourPaques + 39);
+    const LundiPentecote = new Date(year, MoisPaques - 1, JourPaques + 50);
+    const formatDate = (date) => {
+        const dayIndex = date.getDate();
+        const monthIndex = date.getMonth();
+        const day = dayIndex < 10 ? `0${dayIndex.toString()}` : dayIndex;
+        const month = monthIndex + 1 < 10 ? `0${(monthIndex + 1).toString()}` : monthIndex + 1;
+        return `${day}/${month}/${date.getFullYear()}`;
+    };
+    return [
+        JourAn,
+        LundiPaques,
+        FeteTravail,
+        Victoire1945,
+        LundiPentecote,
+        Ascension,
+        FeteNationale,
+        Assomption,
+        Toussaint,
+        Armistice,
+        Noel,
+    ].map((d) => formatDate(d));
+};
+for (let i = 2000; i < 2050; i += 1) {
+    holidays = [...holidays, ...frenchHolidays(i)];
+}
+const dateStringRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/;
+const yearStringRegex = /^([0-9]{4})$/;
+const timestampRegex = /^([0-9]+)$/;
+const varTagRegex = /^\[var:([0-9]+)\]$/;
+export class EvalFunctions extends EvalBase {
+    constructor() {
+        super(...arguments);
+        this.holidays = holidays;
+        this.afficherDate = (varRef) => {
+            let result = '';
+            const date = this.parseVariableArgumentDate(varRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                result = moment.unix(parseInt(date, 10)).utc().format('DD/MM/YYYY');
+            }
+            else {
+                result = moment.utc(date, 'DD/MM/YYYY').utc().format('DD/MM/YYYY');
+            }
+            if (!dateStringRegex.test(result))
+                return '';
+            return `'${result}'`;
+        };
+        this.afficherAnnee = (varRef) => {
+            let result = '';
+            const date = this.parseVariableArgumentDate(varRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                result = moment.unix(parseInt(date, 10)).utc().format('YYYY');
+            }
+            else {
+                result = moment.utc(date, 'DD/MM/YYYY').utc().format('YYYY');
+            }
+            if (!yearStringRegex.test(result))
+                return '';
+            return `'${result}'`;
+        };
+        this.date = (varRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return 0;
+            }
+            return moment.utc(date, 'DD/MM/YYYY').unix();
+        };
+        this.jourOuvre = (varRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            let momentDate;
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date) && moment.unix(parseInt(date, 10))) {
+                momentDate = moment.unix(parseInt(date, 10)).utc();
+            }
+            else {
+                momentDate = moment.utc(date, 'DD/MM/YYYY');
+            }
+            if (!momentDate.isBusinessDay()) {
+                momentDate = momentDate.nextBusinessDay();
+            }
+            return momentDate.utc().format('DD/MM/YYYY');
+        };
+        this.jourOuvrable = (varRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5, 6],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            let momentDate;
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date) && moment.unix(parseInt(date, 10))) {
+                momentDate = moment.unix(parseInt(date, 10)).utc();
+            }
+            else {
+                momentDate = moment.utc(date, 'DD/MM/YYYY');
+            }
+            if (!momentDate.isBusinessDay()) {
+                momentDate = momentDate.nextBusinessDay();
+            }
+            return momentDate.utc().format('DD/MM/YYYY');
+        };
+        this.ajouterJoursOuvres = (varRef, businessDaysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let businessDays = businessDaysRef;
+            if (varTagRegex.test(businessDays))
+                businessDays = this.parseVariableArgumentDate(businessDaysRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .businessAdd(parseInt(businessDays, 10))
+                    .utc()
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .businessAdd(parseInt(businessDays, 10))
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.ajouterJoursOuvrables = (varRef, businessDaysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let businessDays = businessDaysRef;
+            if (varTagRegex.test(businessDays))
+                businessDays = this.parseVariableArgumentDate(businessDaysRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5, 6],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .businessAdd(parseInt(businessDays, 10))
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .businessAdd(parseInt(businessDays, 10))
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.ajouterJours = (varRef, daysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let days = daysRef;
+            if (varTagRegex.test(days))
+                days = this.parseVariableArgumentDate(daysRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .add(days, 'd')
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .add(days, 'd')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.ajouterMois = (varRef, monthsRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let months = monthsRef;
+            if (varTagRegex.test(months))
+                months = this.parseVariableArgumentDate(monthsRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .add(months, 'M')
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .add(months, 'M')
+                .subtract(1, 'd')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.ajouterAnnees = (varRef, yearsRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let years = yearsRef;
+            if (varTagRegex.test(years))
+                years = this.parseVariableArgumentDate(yearsRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .add(years, 'y')
+                    .utc()
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .add(years, 'y')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.enleverJoursOuvrables = (varRef, businessDaysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let businessDays = businessDaysRef;
+            if (varTagRegex.test(businessDays))
+                businessDays = this.parseVariableArgumentDate(businessDaysRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5, 6],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .businessSubtract(parseInt(businessDays, 10))
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .businessSubtract(parseInt(businessDays, 10))
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.enleverJoursOuvres = (varRef, businessDaysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let businessDays = businessDaysRef;
+            if (varTagRegex.test(businessDays))
+                businessDays = this.parseVariableArgumentDate(businessDaysRef);
+            moment.updateLocale('en', {
+                workingWeekdays: [1, 2, 3, 4, 5],
+                holidays,
+                holidayFormat: 'DD/MM/YYYY',
+            });
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .businessSubtract(parseInt(businessDays, 10))
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .businessSubtract(parseInt(businessDays, 10))
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.enleverJours = (varRef, daysRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let days = daysRef;
+            if (varTagRegex.test(days))
+                days = this.parseVariableArgumentDate(daysRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .subtract(days, 'd')
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .subtract(days, 'd')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.enleverMois = (varRef, monthsRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let months = monthsRef;
+            if (varTagRegex.test(months))
+                months = this.parseVariableArgumentDate(monthsRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .subtract(months, 'M')
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .subtract(months, 'M')
+                .subtract(1, 'd')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.enleverAnnees = (varRef, yearsRef) => {
+            const date = this.parseVariableArgumentDate(varRef);
+            let years = yearsRef;
+            if (varTagRegex.test(years))
+                years = this.parseVariableArgumentDate(yearsRef);
+            if (!dateStringRegex.test(date) && !timestampRegex.test(date)) {
+                this.doNotEvaluate = true;
+                return '';
+            }
+            if (!dateStringRegex.test(date)) {
+                return moment
+                    .unix(parseInt(date, 10))
+                    .utc()
+                    .subtract(years, 'y')
+                    .format('DD/MM/YYYY');
+            }
+            return moment
+                .utc(date, 'DD/MM/YYYY')
+                .subtract(years, 'y')
+                .utc()
+                .format('DD/MM/YYYY');
+        };
+        this.dureeJours = (varRefA, varRefB) => {
+            const dateA = this.parseVariableArgumentDate(varRefA);
+            const dateB = this.parseVariableArgumentDate(varRefB);
+            if ((!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+                (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))) {
+                this.doNotEvaluate = true;
+                return 0;
+            }
+            const dateAMoment = !dateStringRegex.test(dateA)
+                ? moment.unix(parseInt(dateA, 10)).utc()
+                : moment.utc(dateA, 'DD/MM/YYYY');
+            const dateBMoment = !dateStringRegex.test(dateB)
+                ? moment.unix(parseInt(dateB, 10)).utc()
+                : moment.utc(dateB, 'DD/MM/YYYY');
+            return dateBMoment.diff(dateAMoment, 'days');
+        };
+        this.dureeMois = (varRefA, varRefB) => {
+            const dateA = this.parseVariableArgumentDate(varRefA);
+            const dateB = this.parseVariableArgumentDate(varRefB);
+            if ((!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+                (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))) {
+                this.doNotEvaluate = true;
+                return 0;
+            }
+            const dateAMoment = !dateStringRegex.test(dateA)
+                ? moment.unix(parseInt(dateA, 10)).utc()
+                : moment.utc(dateA, 'DD/MM/YYYY');
+            const dateBMoment = !dateStringRegex.test(dateB)
+                ? moment.unix(parseInt(dateB, 10)).utc()
+                : moment.utc(dateB, 'DD/MM/YYYY');
+            return dateBMoment.diff(dateAMoment, 'months', true);
+        };
+        this.dureeAnnees = (varRefA, varRefB) => {
+            const dateA = this.parseVariableArgumentDate(varRefA);
+            const dateB = this.parseVariableArgumentDate(varRefB);
+            if ((!dateStringRegex.test(dateA) && !timestampRegex.test(dateA)) ||
+                (!dateStringRegex.test(dateB) && !timestampRegex.test(dateB))) {
+                this.doNotEvaluate = true;
+                return 0;
+            }
+            const dateAMoment = !dateStringRegex.test(dateA)
+                ? moment.unix(parseInt(dateA, 10)).utc()
+                : moment.utc(dateA, 'DD/MM/YYYY');
+            const dateBMoment = !dateStringRegex.test(dateB)
+                ? moment.unix(parseInt(dateB, 10)).utc()
+                : moment.utc(dateB, 'DD/MM/YYYY');
+            return dateBMoment.diff(dateAMoment, 'years', true);
+        };
+        this.today = () => moment
+            .utc()
+            .set({
+            hour: 0,
+            minute: 0,
+            second: 0,
+            millisecond: 0,
+        })
+            .format('DD/MM/YYYY');
+        this.somme = (varRef) => {
+            if (!varTagRegex.test(varRef))
+                return 0;
+            const values = this.getVariableValue(varRef, true).map((value) => {
+                if (typeof value === 'number')
+                    return value;
+                if (!Number.isNaN(parseFloat(value)))
+                    return parseFloat(value);
+                return 0;
+            });
+            return values.reduce((p, c) => p + c, 0);
+        };
+        this.lettres = (varRef) => {
+            if (!varTagRegex.test(varRef) && /[0-9]+/.test(varRef))
+                return '';
+            let result = varRef;
+            if (varTagRegex.test(varRef))
+                result = this.getVariableValue(varRef, false);
+            try {
+                result = NumberToLetter.French(result);
+            }
+            catch (e) {
+                result = '';
+            }
+            return `D=${result}`;
+        };
+    }
+    parseVariableArgumentDate(varRef) {
+        let result = varRef;
+        if (varTagRegex.test(varRef))
+            result = this.getVariableValue(varRef, false);
+        return typeof result === 'number' ? result.toString() : result;
+    }
+}

package/dist/libs/Eval/NumbersToLetters.d.ts

@@ -0,0 +1,3 @@
+export declare class NumberToLetter {
+    static French(number: string | number, units?: string | false, decimals?: string | false): string;
+}

package/dist/libs/Eval/NumbersToLetters.js

@@ -0,0 +1,151 @@
+export class NumberToLetter {
+    static French(number, units = false, decimals = false) {
+        const letter = {
+            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 = '';
+        if (number.toString().replace(/ /gi, '').length > 15)
+            throw new Error('Capacity overrun');
+        if (Number.isNaN(number.toString().replace(/ /gi, '')))
+            throw new Error('Unvalid number');
+        const nb = parseFloat(number.toString().replace(/ /gi, ''));
+        if (Math.ceil(nb) !== nb) {
+            const [wholeNumberPart, decimalPart] = number.toString().split('.');
+            const decimalNumber = (decimalPart === null || decimalPart === void 0 ? void 0 : 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}` : ''));
+        }
+        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/dist/libs/EvalVariable.d.ts

@@ -0,0 +1,15 @@
+import type { VariableV3 } from '@legalplace/models-v3-types';
+import { EvalFunctions } from './Eval/EvalFunctions';
+export declare class EvalVariable extends EvalFunctions {
+    variablesValues: Record<string, string | number>;
+    evaluation: string;
+    rawEvaluation: string;
+    result: string | number | null;
+    index: number;
+    hasFunctions: boolean;
+    abortEvaluation: boolean;
+    constructor(variable: VariableV3, index: number);
+    populateValues(): void;
+    executeFunctions(): void;
+    evaluate(): string | number;
+}