@legalplace/conditions-runner 1.1.0

package/.eslintignore

@@ -0,0 +1,2 @@
+*.test.ts
+*.test.tsx

package/.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": ["@legalplace/eslint-config"]
+}

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# 1.1.0 (2021-12-15)
+
+
+### Features
+
+* add ConditionsRunner package api[#4501](https://git.legalplace.eu/legalplace/monorepo/issues/4501) ([5b55892](https://git.legalplace.eu/legalplace/monorepo/commits/5b558924c72a11c059b7f0296848af1a0e5c80e8))

package/dist/ConditionsRunner.d.ts

@@ -0,0 +1,19 @@
+import { Types } from "@legalplace/referencesparser";
+import { ConditionV3 } from "@legalplace/models-v3-types";
+import type InputsType from "@legalplace/types/dist/inputs";
+import { ConditionDataMap } from "./types/conditions.d";
+declare class ConditionsRunner {
+    private references;
+    private ovc;
+    constructor(references: Types.ReferencesType, ovc: InputsType);
+    isOptionRelatedToOption(optionA: number, optionB: number): boolean;
+    isVariableRelatedToOption(variableId: number, optionId: number): boolean;
+    isVariableRelatedToVariable(variableA: number, variableB: number): boolean;
+    private executeConditionMemo;
+    private buildMemoizeKey;
+    executeCondition(condition: {
+        dataMap: ConditionDataMap;
+        conditions: ConditionV3;
+    }, id: number, index: number, conditionType: "options" | "optionValidator" | "variables" | "prefillers" | "variableValidator" | "sections" | "documents"): any;
+}
+export default ConditionsRunner;

package/dist/ConditionsRunner.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lplogic_1 = __importDefault(require("@legalplace/lplogic"));
+const DataPopulator_1 = __importDefault(require("./DataPopulator"));
+class ConditionsRunner {
+    constructor(references, ovc) {
+        this.executeConditionMemo = {};
+        this.buildMemoizeKey = (condition, id, index, conditionType) => `${JSON.stringify(condition)}-${id}-${index}-${conditionType}`;
+        this.references = references;
+        this.ovc = ovc;
+    }
+    isOptionRelatedToOption(optionA, optionB) {
+        const OptionBParents = this.references.relations.options[optionB].parents;
+        const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        const OptionBRootRelations = OptionBRoot
+            ? this.references.relations.options[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 = this.references.relations.variables[variableId].parents[0];
+        const optionParents = this.references.relations.options[variableParentId].parents;
+        const optionRoot = optionParents[optionParents.length - 1];
+        const optionRootRelations = optionRoot
+            ? this.references.relations.options[optionRoot]
+            : undefined;
+        if (optionRootRelations) {
+            if (optionRootRelations.children.options.includes(optionId) ||
+                optionRootRelations.dependants.includes(optionId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isVariableRelatedToVariable(variableA, variableB) {
+        const optionA = this.references.relations.variables[variableA].parents[0];
+        const optionB = this.references.relations.variables[variableB].parents[0];
+        const OptionBParents = this.references.relations.options[optionB].parents;
+        const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        const OptionBRootRelations = OptionBRoot
+            ? this.references.relations.options[OptionBRoot]
+            : undefined;
+        if (OptionBRootRelations) {
+            if (optionA === optionB ||
+                OptionBRootRelations.children.options.includes(optionA) ||
+                OptionBRootRelations.dependants.includes(optionA)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    executeCondition(condition, id, index, conditionType) {
+        const memoizedKey = this.buildMemoizeKey(condition, id, index, conditionType);
+        if (this.executeConditionMemo[memoizedKey])
+            return this.executeConditionMemo[memoizedKey];
+        let currentData;
+        if (conditionType === "options" || conditionType === "optionValidator") {
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
+        }
+        else if (conditionType === "variables" ||
+            conditionType === "prefillers" ||
+            conditionType === "variableValidator") {
+            const dataId = this.references.relations.variables[id].parents[0];
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, dataId, index).getData();
+        }
+        else if (conditionType === "sections" || conditionType === "documents") {
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
+        }
+        const result = (0, lplogic_1.default)(condition.conditions, currentData);
+        this.executeConditionMemo[memoizedKey] = result;
+        return result;
+    }
+}
+exports.default = ConditionsRunner;

package/dist/ConditionsRunner.test.d.ts

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

package/dist/ConditionsRunner.test.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
+const inputs_type_json_1 = __importDefault(require("./fixtures/inputs-type.json"));
+const references_json_1 = __importDefault(require("./fixtures/references.json"));
+describe("ConditionsRunner class", () => {
+    it("should not raise error when instanciating class", () => {
+        expect(new ConditionsRunner_1.default(references_json_1.default, inputs_type_json_1.default)).toBeDefined();
+    });
+});

package/dist/DataPopulator.d.ts

@@ -0,0 +1,29 @@
+import { Types } from "@legalplace/referencesparser";
+import type InputsType from "@legalplace/types/dist/inputs";
+import ConditionsRunner from "./ConditionsRunner";
+import { ConditionData, ConditionDataMap } from "./types/conditions.d";
+declare class DataPopulator {
+    private references;
+    private ovc;
+    private conditionsRunner;
+    private id?;
+    private index?;
+    private dataMap;
+    private data;
+    constructor(conditionsRunner: ConditionsRunner, references: Types.ReferencesType, ovc: InputsType, dataMap: ConditionDataMap, id?: number, index?: number);
+    getData(): Readonly<ConditionData>;
+    private populateConditions;
+    private getOptionConditions;
+    private getVariablesConditions;
+    private populateVariables;
+    private getVariableValues;
+    private getVariableRootParent;
+    private cleanArrayFromNullValues;
+    populateOptions(): void;
+    private getOptionInputs;
+    private getOptionRootParent;
+    private optionConditionValue;
+    private variableConditionValue;
+    private sectionConditionValue;
+}
+export default DataPopulator;

package/dist/DataPopulator.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataPopulator {
+    constructor(conditionsRunner, references, ovc, dataMap, id, index) {
+        this.data = {
+            o: {},
+            v: {},
+            c: {
+                o: {},
+                s: {},
+                v: {},
+            },
+        };
+        this.id = id;
+        this.ovc = ovc;
+        this.index = index;
+        this.dataMap = dataMap;
+        this.references = references;
+        this.conditionsRunner = conditionsRunner;
+        this.populateVariables();
+        this.populateOptions();
+        this.populateConditions();
+    }
+    getData() {
+        return this.data;
+    }
+    populateConditions() {
+        for (let i = 0; i < this.dataMap.c.s.length; i += 1) {
+            const sectionId = this.dataMap.c.s[i];
+            const sectionCondition = this.sectionConditionValue(sectionId);
+            this.data.c.s[sectionId] = [sectionCondition !== false];
+        }
+        for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
+            const optionId = this.dataMap.c.o[i];
+            const optionCondition = [...this.getOptionConditions(optionId)];
+            this.data.c.o[optionId] =
+                optionCondition === undefined ? [false] : optionCondition;
+        }
+        for (let i = 0; i < this.dataMap.c.v.length; i += 1) {
+            const variableId = this.dataMap.c.v[i];
+            const variableCondition = [...this.getVariablesConditions(variableId)];
+            this.data.c.v[variableId] =
+                variableCondition === undefined ? [false] : variableCondition;
+        }
+    }
+    getOptionConditions(optionId) {
+        const conditions = this.optionConditionValue(optionId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        const optionRootParent = this.getOptionRootParent(optionId);
+        const optionRootRelations = this.references.relations.options[optionRootParent];
+        if (optionRootRelations.children.options.includes(this.id) ||
+            optionRootRelations.dependants.includes(this.id) ||
+            this.id === optionRootParent) {
+            if (conditions !== undefined && conditions[this.index] === false)
+                return [false];
+            return [conditions[this.index]];
+        }
+        return conditions;
+    }
+    getVariablesConditions(variableId) {
+        const conditions = this.variableConditionValue(variableId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        const variableRootParent = this.getVariableRootParent(variableId);
+        const variableRootRelations = this.references.relations.options[variableRootParent];
+        if (variableRootRelations.children.options.includes(this.id) ||
+            variableRootRelations.dependants.includes(this.id) ||
+            this.id === variableRootParent) {
+            return [conditions[this.index]];
+        }
+        return conditions;
+    }
+    populateVariables() {
+        for (let i = 0; i < this.dataMap.v.length; i += 1) {
+            const variableId = this.dataMap.v[i];
+            const variableReference = this.references.variables[variableId];
+            let values = this.getVariableValues(variableId);
+            const parseNumber = (v) => {
+                const result = parseFloat(v);
+                return Number.isNaN(result) ? "" : result;
+            };
+            if (variableReference.type === "number") {
+                values = values.map((v) => typeof v === "number" ? v : parseNumber(v));
+            }
+            this.data.v[variableId] = [...values];
+        }
+    }
+    getVariableValues(variableId) {
+        const value = this.ovc.variables[variableId];
+        if (this.id === undefined || this.index === undefined) {
+            return value;
+        }
+        const variableRootParent = this.getVariableRootParent(variableId);
+        const variableRootRelations = this.references.relations.options[variableRootParent];
+        if (variableRootRelations.children.options.includes(this.id) ||
+            variableRootRelations.dependants.includes(this.id) ||
+            this.id === variableRootParent) {
+            return [value[this.index]];
+        }
+        return this.cleanArrayFromNullValues([...value]);
+    }
+    getVariableRootParent(variableId) {
+        const variableParents = this.references.relations.variables[variableId].parents;
+        return variableParents[variableParents.length - 1];
+    }
+    cleanArrayFromNullValues(arr) {
+        return arr.map((v) => (v === null ? "" : v));
+    }
+    populateOptions() {
+        for (let i = 0; i < this.dataMap.o.length; i += 1) {
+            const optionId = this.dataMap.o[i];
+            const inputs = this.getOptionInputs(optionId);
+            this.data.o[optionId] = [...inputs];
+        }
+    }
+    getOptionInputs(optionId) {
+        const inputs = this.ovc.options[optionId];
+        if (this.id === undefined || this.index === undefined) {
+            return inputs;
+        }
+        const optionRootParent = this.getOptionRootParent(optionId);
+        const optionRootRelations = this.references.relations.options[optionRootParent];
+        if (optionRootRelations.children.options.includes(this.id) ||
+            optionRootRelations.dependants.includes(this.id) ||
+            this.id === optionRootParent) {
+            return [inputs[this.index]];
+        }
+        return inputs;
+    }
+    getOptionRootParent(optionId) {
+        const optionParents = this.references.relations.options[optionId].parents;
+        return optionParents.length > 0
+            ? optionParents[optionParents.length - 1]
+            : optionId;
+    }
+    optionConditionValue(optionId) {
+        const conditions = this.references.conditions.options[optionId];
+        if (conditions === undefined)
+            return undefined;
+        const inputs = this.ovc.options[optionId];
+        return inputs.map((input, index) => this.conditionsRunner.executeCondition(conditions, optionId, index, "options"));
+    }
+    variableConditionValue(variableId) {
+        const conditions = this.references.conditions.variables[variableId];
+        if (conditions === undefined)
+            return undefined;
+        const inputs = this.ovc.variables[variableId];
+        const result = inputs.map((input, index) => this.conditionsRunner.executeCondition(conditions, variableId, index, "variables"));
+        return result;
+    }
+    sectionConditionValue(sectionId) {
+        const conditions = this.references.conditions.sections.main[sectionId];
+        if (conditions === undefined)
+            return undefined;
+        return this.conditionsRunner.executeCondition(conditions, 0, 0, "sections");
+    }
+}
+exports.default = DataPopulator;