@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/libs/ConditionsRunner.js

@@ -0,0 +1,254 @@
+import LpLogic from '@legalplace/lplogic/dist/LpLogic';
+import { selectOptionInput } from '../redux/selectors/inputs';
+import { selectOptionRelations, selectVariableRelations, selectVariableParents, selectOptionParents, selectOptionConditionsObject, selectVariableConditionsObject, selectSectionConditionsObject, selectPrefillerConditionsObject, selectOptionValidatorConditionsObject, selectVariableValidatorConditionsObject, selectDocumentConditionsObject, selectOptionReference, selectSectionRelations, } from '../redux/selectors/references';
+import { updateOptionConditionsAction, updateVariableConditionsAction, updateSectionConditionsAction, updatePrefillersConditionsAction, updateOptionValidatorConditionsAction, updateVariableValidatorConditionsAction, updateDocumentConditionsAction, } from '../redux/actions/conditions';
+import { selectOptionConditionValue, selectVariableConditionValue, selectSectionConditionValue, selectPrefillerConditionValue, selectOptionValidatorConditionValue, selectVariableValidatorConditionValue, selectDocumentConditionValue, } from '../redux/selectors/conditions';
+import DataPopulator from './ConditionsRunner/DataPopulator';
+const conditionValueSelectorsEnum = {
+    options: selectOptionConditionValue,
+    variables: selectVariableConditionValue,
+    documents: selectDocumentConditionValue,
+    prefillers: selectPrefillerConditionValue,
+    optionValidator: selectOptionValidatorConditionValue,
+    variableValidator: selectVariableValidatorConditionValue,
+};
+const conditionObjectSelectorsEnum = {
+    options: selectOptionConditionsObject,
+    variables: selectVariableConditionsObject,
+    documents: selectDocumentConditionsObject,
+    prefillers: selectPrefillerConditionsObject,
+    optionValidator: selectOptionValidatorConditionsObject,
+    variableValidator: selectVariableValidatorConditionsObject,
+};
+const updateDispatchActionsEnum = {
+    options: updateOptionConditionsAction,
+    variables: updateVariableConditionsAction,
+    documents: updateDocumentConditionsAction,
+    prefillers: updatePrefillersConditionsAction,
+    optionValidator: updateOptionValidatorConditionsAction,
+    variableValidator: updateVariableValidatorConditionsAction,
+};
+export class ConditionsRunner {
+    constructor(dispatch) {
+        this.dispatch = dispatch;
+    }
+    shouldConditionUpdate(oldCondition, newCondition) {
+        let update = false;
+        if (Array.isArray(oldCondition) && Array.isArray(newCondition)) {
+            oldCondition.forEach((value, index) => {
+                if (Array.isArray(value)) {
+                    update =
+                        update || this.shouldConditionUpdate(value, newCondition[index]);
+                }
+                else {
+                    update = update || value !== newCondition[index];
+                }
+            });
+        }
+        else {
+            update = oldCondition !== newCondition;
+        }
+        return update;
+    }
+    isOptionRelatedToOption(optionA, optionB) {
+        const OptionBParents = selectOptionParents(optionB);
+        const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        const OptionBRootRelations = OptionBRoot
+            ? selectOptionRelations(OptionBRoot)
+            : undefined;
+        if (OptionBRootRelations) {
+            if (optionA === optionB ||
+                OptionBRootRelations.children.options.includes(optionA) ||
+                OptionBRootRelations.dependants.includes(optionA)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isVariableRelatedToOption(variableId, optionId) {
+        const variableParentId = selectVariableParents(variableId)[0];
+        const optionParents = selectOptionParents(variableParentId);
+        const optionRoot = optionParents.length > 0
+            ? optionParents[optionParents.length - 1]
+            : variableParentId;
+        const optionRootRelations = optionRoot
+            ? selectOptionRelations(optionRoot)
+            : undefined;
+        if (optionRootRelations) {
+            if (optionRootRelations.children.options.includes(optionId) ||
+                optionRootRelations.dependants.includes(optionId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isVariableRelatedToVariable(variableA, variableB) {
+        const optionA = selectVariableParents(variableA)[0];
+        const optionB = selectVariableParents(variableB)[0];
+        const OptionBParents = selectOptionParents(optionB);
+        const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        const OptionBRootRelations = OptionBRoot
+            ? selectOptionRelations(OptionBRoot)
+            : undefined;
+        if (OptionBRootRelations) {
+            if (optionA === optionB ||
+                OptionBRootRelations.children.options.includes(optionA) ||
+                OptionBRootRelations.dependants.includes(optionA)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getInputsForOption(optionId) {
+        let inputId = optionId;
+        const optionReference = selectOptionReference(optionId);
+        const optionParents = selectOptionParents(optionId);
+        if (optionParents.length > 0) {
+            const parentReference = selectOptionReference(optionParents[0]);
+            if (parentReference.meta.type === 'repeated' &&
+                parentReference.meta.repeatOption !== undefined) {
+                inputId = parentReference.meta.repeatOption;
+            }
+        }
+        else if (optionReference.meta.type === 'repeated' &&
+            optionReference.meta.repeatOption !== undefined) {
+            inputId = optionReference.meta.repeatOption;
+        }
+        return selectOptionInput(inputId).map((input, currentIndex) => currentIndex);
+    }
+    getInputsForVariable(variableId) {
+        const optionId = selectVariableParents(variableId)[0];
+        let inputId = optionId;
+        const optionParents = selectOptionParents(optionId);
+        if (optionParents.length > 0) {
+            const parentReference = selectOptionReference(optionParents[0]);
+            if (parentReference.meta.type === 'repeated' &&
+                parentReference.meta.repeatOption !== undefined) {
+                inputId = parentReference.meta.repeatOption;
+            }
+        }
+        return selectOptionInput(inputId).map((input, currentIndex) => currentIndex);
+    }
+    executeHooks(type, id, index) {
+        let hooks;
+        switch (type) {
+            case 'options':
+                hooks = selectOptionRelations(id);
+                break;
+            case 'variables':
+                hooks = selectVariableRelations(id);
+                break;
+            case 'sections':
+                hooks = selectSectionRelations(id);
+                break;
+            default:
+                throw new Error(`Unkown hook type ${type}`);
+        }
+        const subTypesList = [
+            'options',
+            'variables',
+            'sections',
+            'prefillers',
+            'optionValidator',
+            'variableValidator',
+            'documents',
+        ];
+        subTypesList.forEach((subType) => {
+            if (subType === 'sections') {
+                return this.executeSectionsHooks(hooks, index);
+            }
+            let currentHooks;
+            if (subType === 'optionValidator' || subType === 'variableValidator') {
+                currentHooks =
+                    hooks.validators[subType === 'optionValidator' ? 'options' : 'variables'];
+            }
+            else {
+                currentHooks = hooks[subType];
+            }
+            currentHooks.forEach((currentId) => {
+                const execId = subType === 'documents' ? 0 : currentId;
+                const updateId = subType === 'documents' ? currentId : currentId;
+                let execIndexes = [];
+                if (['options', 'optionValidator'].includes(subType) &&
+                    typeof updateId === 'number') {
+                    if (type === 'options' &&
+                        this.isOptionRelatedToOption(updateId, id)) {
+                        execIndexes = [index];
+                    }
+                    else if (type === 'variables' &&
+                        this.isVariableRelatedToOption(id, updateId)) {
+                        execIndexes = [index];
+                    }
+                    else {
+                        execIndexes = this.getInputsForOption(updateId);
+                    }
+                }
+                else if (['variables', 'prefillers', 'variableValidator'].includes(subType) &&
+                    typeof updateId === 'number') {
+                    if (type === 'options' &&
+                        this.isVariableRelatedToOption(updateId, id)) {
+                        execIndexes = [index];
+                    }
+                    else if (type === 'variables' &&
+                        this.isVariableRelatedToVariable(id, updateId)) {
+                        execIndexes = [index];
+                    }
+                    else {
+                        execIndexes = this.getInputsForVariable(updateId);
+                    }
+                }
+                else {
+                    execIndexes = [0];
+                }
+                for (let i = 0; i < execIndexes.length; i += 1) {
+                    const condition = conditionObjectSelectorsEnum[subType](currentId);
+                    const newCondition = this.executeCondition(condition, execId, execIndexes[i], subType);
+                    const oldCondition = conditionValueSelectorsEnum[subType](currentId, execIndexes[i]);
+                    if (this.shouldConditionUpdate(oldCondition, newCondition)) {
+                        this.dispatch(updateDispatchActionsEnum[subType](updateId, execIndexes[i], newCondition));
+                    }
+                }
+            });
+            return null;
+        });
+    }
+    executeSectionsHooks(hooks, index) {
+        Object.keys(hooks.sections).forEach((currentDocument) => {
+            hooks.sections[currentDocument].forEach((currentId) => {
+                const condition = selectSectionConditionsObject(parseInt(currentId, 10), currentDocument);
+                const newCondition = this.executeCondition(condition, parseInt(currentId, 10), index, 'sections');
+                const oldCondition = selectSectionConditionValue(parseInt(currentId, 10), currentDocument);
+                if (this.shouldConditionUpdate(oldCondition, newCondition)) {
+                    this.dispatch(updateSectionConditionsAction(parseInt(currentId, 10), currentDocument, newCondition));
+                }
+            });
+        });
+    }
+    executeCondition(condition, id, index, conditionType) {
+        if (Array.isArray(condition))
+            return condition.map((_condition) => this.executeCondition(_condition, id, index, conditionType));
+        if (!(typeof condition === 'object' &&
+            typeof condition.conditions === 'object' &&
+            Object.keys(condition.conditions).length > 0))
+            return true;
+        let currentData;
+        if (conditionType === 'options' || conditionType === 'optionValidator') {
+            currentData = new DataPopulator(condition.dataMap, id, index).getData();
+        }
+        else if (conditionType === 'variables' ||
+            conditionType === 'prefillers' ||
+            conditionType === 'variableValidator') {
+            const dataId = selectVariableParents(id)[0];
+            currentData = new DataPopulator(condition.dataMap, dataId, index).getData();
+        }
+        else if (conditionType === 'sections' ||
+            conditionType === 'documents' ||
+            conditionType === 'raw') {
+            currentData = new DataPopulator(condition.dataMap).getData();
+        }
+        return LpLogic(condition.conditions, currentData);
+    }
+    executeRawCondition(condition) {
+        return this.executeCondition(condition, 0, 0, 'raw');
+    }
+}

package/dist/libs/DocumentsOutputs.d.ts

@@ -0,0 +1,26 @@
+import type { SectionV3, OptionV3, VariableV3 } from '@legalplace/models-v3-types';
+import type { ReferencesSingleOutputType, ReferencesSectionsDocumentType } from '@legalplace/referencesparser/dist/libs/References.type';
+export interface GettersType {
+    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;
+    optionInputs: (id: number) => Readonly<boolean[]>;
+    variablesInputs: (id: number) => Readonly<(string | number)[]>;
+    optionConditions: (id: number, index: number) => Readonly<boolean | undefined>;
+    sectionConditions: (id: number, document: string) => Readonly<boolean | undefined>;
+}
+export declare class DocumentsOutputs {
+    private getters;
+    private documentSections;
+    private document;
+    private outputs;
+    constructor(getters: GettersType, document: string);
+    getOutputs(): Record<string, string>;
+    private loopThroughtSections;
+    private parseSection;
+    private parseOption;
+    private parseRepeated;
+    private parseHidden;
+}

package/dist/libs/DocumentsOutputs.js

@@ -0,0 +1,78 @@
+import { NumAuto } from './NumAuto';
+import { getRelatedVariablesValues, parseOutputWithVariables, } from '../helpers/outputsParsing';
+export class DocumentsOutputs {
+    constructor(getters, document) {
+        this.documentSections = {};
+        this.outputs = {};
+        this.getters = getters;
+        this.document = document;
+        const documentSections = getters.documentSections(document);
+        if (documentSections === undefined)
+            return;
+        this.documentSections = documentSections;
+        NumAuto.resetNums();
+        this.loopThroughtSections();
+    }
+    getOutputs() {
+        return this.outputs;
+    }
+    loopThroughtSections() {
+        Object.keys(this.documentSections).forEach((sectionId) => {
+            const section = this.documentSections[sectionId];
+            this.parseSection(section);
+        });
+    }
+    parseSection(section) {
+        section.options.forEach((option) => {
+            this.parseOption(option);
+        });
+    }
+    parseOption(id) {
+        const option = this.getters.optionReference(id);
+        if (!['hidden', 'repeated'].includes(option.meta.type))
+            return;
+        if (option.meta.type === 'repeated')
+            this.parseRepeated(option);
+        else
+            this.parseHidden(option);
+    }
+    parseRepeated(option) {
+        const { id, repeatOption } = option.meta;
+        if (repeatOption === undefined)
+            throw new Error(`Repeated option ${id} is not linked to any multiple`);
+        const inputs = this.getters.optionInputs(repeatOption);
+        inputs.forEach((input, index) => {
+            const condition = this.getters.optionConditions(repeatOption, index);
+            if (condition === false || input === false)
+                return;
+            this.parseHidden(option, index, true, inputs.length);
+            option.options.forEach((childId) => {
+                const childOption = this.getters.optionReference(childId);
+                this.parseHidden(childOption, index, true, inputs.length);
+            });
+        });
+    }
+    parseHidden(option, index = 0, forcedTruthyInput = false, siblingsCount = 0) {
+        const { id } = option.meta;
+        const outputReference = this.getters.outputReference(id);
+        if (outputReference === undefined)
+            return;
+        if (outputReference.raw.trim().length === 0)
+            return;
+        const input = forcedTruthyInput === true ? true : this.getters.optionInputs(id)[index];
+        const condition = this.getters.optionConditions(id, index);
+        if (condition === false || input === false)
+            return;
+        const variables = getRelatedVariablesValues(id, index, outputReference.variables);
+        const autonums = 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/dist/libs/Eval/EvalBase.d.ts

@@ -0,0 +1,13 @@
+export declare class EvalBase {
+    index: number;
+    id: number;
+    doNotEvaluate: boolean;
+    isDisplay: boolean;
+    constructor(id: number, index: number);
+    getVariableValue(varRef: string | number, full?: true): (string | number)[];
+    getVariableValue(varRef: string | number, full?: false): string | number;
+    parseNumber(value: string | number): string | number;
+    setEmpty(value: string | number, replacer: string | number): string | number;
+    setCommas(value: string | number): string | number;
+    isVariableEditable(varRef: string | number): Readonly<boolean>;
+}

package/dist/libs/Eval/EvalBase.js

@@ -0,0 +1,69 @@
+import { selectVariableInputByIndex, selectVariableInput, } from '../../redux/selectors/inputs';
+import { areVariablesSiblings, selectVariableReference, } from '../../redux/selectors/references';
+import { selectIsVariableDisplayed } from '../../redux/selectors/conditions';
+export class EvalBase {
+    constructor(id, index) {
+        this.doNotEvaluate = false;
+        this.isDisplay = false;
+        this.id = id;
+        this.index = index;
+    }
+    getVariableValue(varRef, full = false) {
+        let variableId;
+        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;
+        let value;
+        if (full === false) {
+            value = selectVariableInputByIndex(variableId, index);
+            if (selectIsVariableDisplayed(variableId, index) === false)
+                return '';
+            return this.parseNumber(value);
+        }
+        value = selectVariableInput(variableId);
+        value = value.map((v, i) => selectIsVariableDisplayed(variableId, i) === true
+            ? this.parseNumber(v)
+            : '');
+        return value;
+    }
+    parseNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (this.isDisplay && typeof value === 'string' && /^0/.test(value.trim()))
+            return value;
+        if (/^([0-9,.]+)$/.test(value.trim()))
+            return parseFloat(value.replace(',', '.').trim());
+        return value;
+    }
+    setEmpty(value, replacer) {
+        return typeof value === 'string'
+            ? value.replace(/___EMPTY___/g, typeof replacer === 'string' ? replacer : replacer.toString())
+            : value;
+    }
+    setCommas(value) {
+        const stringValue = typeof value === 'number' ? value.toString() : value;
+        return /^([0-9,.]+)$/.test(stringValue.trim())
+            ? stringValue.replace('.', ',').trim()
+            : value;
+    }
+    isVariableEditable(varRef) {
+        let variableId;
+        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);
+        }
+        const variable = selectVariableReference(variableId);
+        const index = areVariablesSiblings(variableId, this.id) ? this.index : 0;
+        return (variable.hidden !== true && selectIsVariableDisplayed(variableId, index));
+    }
+}

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

@@ -0,0 +1,26 @@
+import { EvalBase } from './EvalBase';
+export declare class EvalFunctions extends EvalBase {
+    holidays: string[];
+    private parseVariableArgumentDate;
+    afficherDate: (varRef: string) => string;
+    afficherAnnee: (varRef: string) => string;
+    date: (varRef: string) => number;
+    jourOuvre: (varRef: string) => string;
+    jourOuvrable: (varRef: string) => string;
+    ajouterJoursOuvres: (varRef: string, businessDaysRef: string) => string;
+    ajouterJoursOuvrables: (varRef: string, businessDaysRef: string) => string;
+    ajouterJours: (varRef: string, daysRef: string) => string;
+    ajouterMois: (varRef: string, monthsRef: string) => string;
+    ajouterAnnees: (varRef: string, yearsRef: string) => string;
+    enleverJoursOuvrables: (varRef: string, businessDaysRef: string) => string;
+    enleverJoursOuvres: (varRef: string, businessDaysRef: string) => string;
+    enleverJours: (varRef: string, daysRef: string) => string;
+    enleverMois: (varRef: string, monthsRef: string) => string;
+    enleverAnnees: (varRef: string, yearsRef: string) => string;
+    dureeJours: (varRefA: string, varRefB: string) => number;
+    dureeMois: (varRefA: string, varRefB: string) => number;
+    dureeAnnees: (varRefA: string, varRefB: string) => number;
+    today: () => string;
+    somme: (varRef: string) => number;
+    lettres: (varRef: string) => string;
+}