@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/libs/EvalVariable.js

@@ -0,0 +1,182 @@
+import { selectVariableReference } from '../redux/selectors/references';
+import { EvalFunctions } from './Eval/EvalFunctions';
+export class EvalVariable extends EvalFunctions {
+    constructor(variable, index) {
+        var _a, _b;
+        super(variable.id, index);
+        this.variablesValues = {};
+        this.result = null;
+        this.hasFunctions = false;
+        this.abortEvaluation = false;
+        this.evaluation =
+            typeof ((_a = variable.eval) === null || _a === void 0 ? void 0 : _a.formula) === 'string' ? (_b = variable.eval) === null || _b === void 0 ? void 0 : _b.formula : '0';
+        this.rawEvaluation = this.evaluation;
+        this.index = index;
+        if (/^D=(.*)/i.test(this.evaluation)) {
+            this.isDisplay = true;
+        }
+        this.executeFunctions();
+        this.populateValues();
+        this.evaluate();
+    }
+    populateValues() {
+        let evalVariables = {};
+        const match = this.evaluation.match(/\[var:([0-9]+)\]/gi);
+        if (match !== null) {
+            const evalVariablesTags = [...match];
+            const evalVariablesIds = evalVariablesTags.map((current) => {
+                const matchId = current.match(/([0-9]+)/);
+                if (matchId === null)
+                    return 0;
+                return parseInt(matchId[0], 10);
+            });
+            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 = Object.assign(Object.assign({}, 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;
+    }
+    executeFunctions() {
+        const functionsList = {
+            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,
+        };
+        const regex = /([a-z_]+)\(([^()]*)\)/gi;
+        let formulas = this.evaluation.match(regex);
+        while (formulas && this.doNotEvaluate === false) {
+            formulas.forEach((formula) => {
+                const reg = new RegExp(regex, 'gi');
+                const extract = reg.exec(formula);
+                if (extract === null)
+                    return;
+                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 {
+                    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);
+        }
+    }
+    evaluate() {
+        if (this.doNotEvaluate === true) {
+            this.result = '';
+            return '';
+        }
+        if (typeof this.evaluation !== 'string' ||
+            this.evaluation.trim().length === 0) {
+            this.result = '';
+            return '';
+        }
+        let result;
+        try {
+            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);
+                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;
+        }
+        if (typeof result === 'number') {
+            const variableReference = selectVariableReference(this.id);
+            if ((variableReference === null || variableReference === void 0 ? void 0 : 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;
+            let numberOfDecimals = 0;
+            if (evalDecimal !== undefined) {
+                numberOfDecimals =
+                    typeof evalDecimal === 'string'
+                        ? parseInt(evalDecimal, 10)
+                        : evalDecimal;
+            }
+            let decma = 1;
+            for (let i = 0; i < numberOfDecimals; i += 1)
+                decma *= 10;
+            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/dist/libs/EventsTracking.d.ts

@@ -0,0 +1,21 @@
+export declare type EventsPropsType = Record<string, string | number | boolean | Record<string, string | number | boolean>>;
+declare class _EventsTracking {
+    private initiated;
+    private queue;
+    private queueTimer;
+    track(eventName: string, eventProps?: EventsPropsType): void;
+    register(props: EventsPropsType): void;
+    trigger(name: string): void;
+    private init;
+    private executeQueue;
+    private queueTimeout;
+    trackMix(eventName: string, eventProps?: EventsPropsType, doNotPushToQueue?: boolean): boolean;
+    trackSIB(eventName: string, eventProps?: EventsPropsType, doNotPushToQueue?: boolean): boolean;
+    private trackFB;
+    private trackGA;
+    private registerMix;
+    private registerFB;
+    private triggerHj;
+}
+export declare const EventsTracking: _EventsTracking;
+export {};

package/dist/libs/EventsTracking.js

@@ -0,0 +1,174 @@
+import Globals from '../Globals';
+class _EventsTracking {
+    constructor() {
+        this.initiated = false;
+        this.queue = [];
+        this.queueTimer = null;
+    }
+    track(eventName, eventProps) {
+        if (!this.initiated)
+            this.init();
+        this.trackMix(eventName, Object.assign({}, eventProps));
+        this.trackFB(eventName, Object.assign({}, eventProps));
+        this.trackGA(eventName, Object.assign({}, eventProps));
+        this.trackSIB(eventName, Object.assign({}, eventProps));
+    }
+    register(props) {
+        if (!this.initiated)
+            this.init();
+        this.registerMix(props);
+        this.registerFB(props);
+    }
+    trigger(name) {
+        if (!this.initiated)
+            this.init();
+        this.triggerHj(name);
+    }
+    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');
+    }
+    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;
+                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`);
+                }
+                const result = fn(...args);
+                if (result === true) {
+                    this.queue.splice(i, 1);
+                }
+            }
+        }
+    }
+    queueTimeout() {
+        if (this.queueTimer !== null)
+            clearTimeout(this.queueTimer);
+        this.queueTimer = setTimeout(() => {
+            this.executeQueue();
+        }, 500);
+    }
+    trackMix(eventName, eventProps, 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;
+    }
+    trackSIB(eventName, eventProps, 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;
+    }
+    trackFB(eventName, eventProps, 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;
+    }
+    trackGA(eventName, eventProps, 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;
+    }
+    registerMix(props, 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;
+    }
+    registerFB(props, 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;
+    }
+    triggerHj(name, 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();

package/dist/libs/Extracts.d.ts

@@ -0,0 +1,20 @@
+export interface ExtractObject {
+    name: string;
+    value: string;
+}
+declare class Extracts {
+    private extracts;
+    private slackExtracts;
+    private sendinblueExtracts;
+    private mixpanelExtracts;
+    extractData(): void;
+    getSibExtractedData(): {
+        [k: string]: string;
+    };
+    private prepareExtracts;
+    private sendSlackMessages;
+    private sendMixpanel;
+    private formatSlackMessage;
+}
+declare const _default: Extracts;
+export default _default;

package/dist/libs/Extracts.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { selectCustomizationMeta } from '../redux/selectors/app';
+import { selectUserEmail } from '../redux/selectors/user';
+import { selectOptionInput, selectVariableInput, } from '../redux/selectors/inputs';
+import { selectOptionReference, selectVariableReference, } from '../redux/selectors/references';
+import { EventsTracking } from './EventsTracking';
+class Extracts {
+    constructor() {
+        this.extracts = [];
+        this.slackExtracts = {};
+        this.sendinblueExtracts = {};
+        this.mixpanelExtracts = {};
+    }
+    extractData() {
+        const customizationMeta = selectCustomizationMeta();
+        if (!(typeof customizationMeta === 'object' &&
+            Array.isArray(customizationMeta.extracts) &&
+            customizationMeta.extracts.length > 0))
+            return;
+        this.extracts = customizationMeta.extracts;
+        this.prepareExtracts();
+        this.sendSlackMessages();
+        this.sendMixpanel();
+    }
+    getSibExtractedData() {
+        return this.sendinblueExtracts;
+    }
+    prepareExtracts() {
+        this.extracts.forEach((extract) => {
+            const { id, type, destination } = extract;
+            let inputs;
+            let defaultName;
+            if (type === 'option') {
+                inputs = selectOptionInput(id).map((value) => value === true ? 'True' : 'False');
+                defaultName = selectOptionReference(id).meta.label;
+            }
+            else if (type === 'variable') {
+                inputs = selectVariableInput(id).map((value) => value.toString());
+                defaultName = selectVariableReference(id, true).label;
+            }
+            else {
+                throw new Error(`Unkown extract type ${type}`);
+            }
+            defaultName =
+                defaultName.trim().length > 0 ? defaultName : `${type} ${id}`;
+            const value = inputs.length > 1 ? inputs.join(', ').slice(0, -2) : inputs[0];
+            if (typeof destination.slack === 'object' &&
+                typeof destination.slack.channel === 'string' &&
+                destination.slack.channel.trim().length > 0) {
+                const { name, channel } = destination.slack;
+                if (this.slackExtracts[channel] === undefined)
+                    this.slackExtracts[channel] = [];
+                this.slackExtracts[channel].push({
+                    name: name || defaultName,
+                    value,
+                });
+            }
+            if (typeof destination.sendinblue === 'object' && value && value.trim()) {
+                const name = destination.sendinblue.name || defaultName;
+                this.sendinblueExtracts = Object.assign(Object.assign({}, this.sendinblueExtracts), { [name]: value });
+            }
+            if (typeof destination.mixpanel === 'object') {
+                const name = destination.mixpanel.name || defaultName;
+                this.mixpanelExtracts = Object.assign(Object.assign({}, this.mixpanelExtracts), { [name]: value });
+            }
+        });
+    }
+    sendSlackMessages() {
+        const channels = Object.keys(this.slackExtracts);
+        channels.forEach((currentChannel) => {
+            const text = this.formatSlackMessage(currentChannel);
+            const json = {
+                username: 'WizardX Extract Bot',
+                icon_emoji: ':robot_face:',
+                channel: currentChannel,
+                attachments: [
+                    {
+                        text,
+                    },
+                ],
+            };
+            fetch('https://hooks.slack.com/services/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', {
+                body: JSON.stringify(json),
+                method: 'POST',
+            }).catch((err) => __awaiter(this, void 0, void 0, function* () {
+                throw new Error(err);
+            }));
+        });
+    }
+    sendMixpanel() {
+        EventsTracking.trackMix('Variable Extraction', this.mixpanelExtracts);
+    }
+    formatSlackMessage(channel) {
+        const lines = [`Email: ${selectUserEmail()}`];
+        this.slackExtracts[channel].forEach((extract) => {
+            const { name, value } = extract;
+            lines.push(`*${name}:* ${value}`);
+        });
+        return lines.join('\n');
+    }
+}
+export default new Extracts();

package/dist/libs/InputsInitiator.d.ts

@@ -0,0 +1,19 @@
+import { StateType } from '../types/State.type';
+export declare type OVC_TYPE = {
+    options: {
+        [key: string]: boolean[];
+    };
+    variables: {
+        [key: string]: (number | string)[];
+    };
+};
+export declare class IntputsInitiator {
+    private inputs;
+    private references;
+    private ovc;
+    constructor(references: StateType.References, ovc: OVC_TYPE | null);
+    getInputs(): StateType.Inputs;
+    private setMultiples;
+    private initOptionsInputs;
+    private initVariablesInputs;
+}

package/dist/libs/InputsInitiator.js

@@ -0,0 +1,86 @@
+export class IntputsInitiator {
+    constructor(references, ovc) {
+        this.inputs = {
+            options: {},
+            variables: {},
+        };
+        this.references = references;
+        this.ovc = ovc;
+        this.setMultiples();
+        this.initOptionsInputs();
+        this.initVariablesInputs();
+    }
+    getInputs() {
+        return this.inputs;
+    }
+    setMultiples() {
+        if (this.ovc === null)
+            return;
+        Object.keys(this.ovc.options).forEach((id) => {
+            if (this.ovc === null)
+                return;
+            const inputs = this.ovc.options[id];
+            if (inputs.length > 1) {
+                const parentsTree = this.references.relations.options[id].parents;
+                const rootOptionId = parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
+                if (!this.ovc.options[rootOptionId]) {
+                    const rootReference = this.references.options[rootOptionId];
+                    if (rootReference.meta.type === 'static') {
+                        this.ovc.options[rootOptionId] = new Array(inputs.length).fill(true);
+                    }
+                }
+            }
+        });
+    }
+    initOptionsInputs() {
+        const optionsIds = Object.keys(this.references.options);
+        for (let i = 0; i < optionsIds.length; i += 1) {
+            const optionId = optionsIds[i];
+            const option = this.references.options[optionId];
+            let values = [false];
+            if (this.ovc &&
+                Object.prototype.hasOwnProperty.call(this.ovc.options, optionId)) {
+                if ([
+                    'static',
+                    'hidden',
+                    'brut-text',
+                    'repeated',
+                    'box',
+                    'separator',
+                ].includes(option.meta.type)) {
+                    values = new Array(this.ovc.options[optionId].length).fill(true);
+                }
+                else {
+                    values = this.ovc.options[optionId];
+                }
+            }
+            else if ([
+                'static',
+                'hidden',
+                'brut-text',
+                'repeated',
+                'box',
+                'separator',
+            ].includes(option.meta.type)) {
+                values = [true];
+            }
+            this.inputs.options[optionId] = values;
+        }
+    }
+    initVariablesInputs() {
+        const variablesIds = Object.keys(this.references.variables);
+        for (let i = 0; i < variablesIds.length; i += 1) {
+            const variableId = variablesIds[i];
+            let values = [''];
+            if (this.ovc &&
+                Object.prototype.hasOwnProperty.call(this.ovc.variables, variableId)) {
+                values = this.ovc.variables[variableId];
+            }
+            else {
+                const defaultValue = '';
+                values = [defaultValue];
+            }
+            this.inputs.variables[variableId] = values;
+        }
+    }
+}

package/dist/libs/NumAuto.d.ts

@@ -0,0 +1,9 @@
+declare class _NumAuto {
+    numsList: Record<string, any>;
+    tagsCatalog: Record<string, number>;
+    getNum: (catalog: string, tag: string | null) => number;
+    getNumPre: (catalog: string, index: number, siblingsCount: number) => number;
+    resetNums: () => void;
+}
+export declare const NumAuto: _NumAuto;
+export {};

package/dist/libs/NumAuto.js

@@ -0,0 +1,32 @@
+class _NumAuto {
+    constructor() {
+        this.numsList = {};
+        this.tagsCatalog = {};
+        this.getNum = (catalog, tag) => {
+            if (!Object.prototype.hasOwnProperty.call(this.numsList, catalog)) {
+                if (Object.prototype.hasOwnProperty.call(this.tagsCatalog, catalog))
+                    return this.tagsCatalog[catalog];
+                this.numsList[catalog] = 0;
+            }
+            this.numsList[catalog] += 1;
+            if (typeof tag === 'string')
+                this.tagsCatalog[tag] = this.numsList[catalog];
+            return this.numsList[catalog];
+        };
+        this.getNumPre = (catalog, index, siblingsCount) => {
+            if (!Object.prototype.hasOwnProperty.call(this.numsList, catalog)) {
+                if (Object.prototype.hasOwnProperty.call(this.tagsCatalog, catalog))
+                    return siblingsCount > 0
+                        ? this.tagsCatalog[catalog] - (siblingsCount - (index + 1))
+                        : this.tagsCatalog[catalog];
+            }
+            return siblingsCount > 0
+                ? this.numsList[catalog] - (siblingsCount - (index + 1))
+                : this.numsList[catalog];
+        };
+        this.resetNums = () => {
+            this.numsList = {};
+        };
+    }
+}
+export const NumAuto = new _NumAuto();

package/dist/libs/NumAuto.test.d.ts

@@ -0,0 +1 @@
+export {};