@legalplace/prerenderx 2.1.2 → 2.2.0

package/dist/libs/ConditionsRunner.d.ts

@@ -1,5 +1,6 @@
 import { Types } from "@legalplace/referencesparser";
 import { ConditionV3 } from "@legalplace/models-v3-types";
+import { ConditionDataMap } from "./DataPopulator";
 declare type OVC_TYPE = {
     options: {
         [key: string]: boolean[];
@@ -12,15 +13,11 @@ declare class ConditionsRunner {
     private references;
     private ovc;
     constructor(references: Types.ReferencesType, ovc: OVC_TYPE);
-    private populateData;
     isOptionRelatedToOption(optionA: number, optionB: number): boolean;
     isVariableRelatedToOption(variableId: number, optionId: number): boolean;
     isVariableRelatedToVariable(variableA: number, variableB: number): boolean;
     executeCondition(condition: {
-        dataMap: {
-            o: number[];
-            v: number[];
-        };
+        dataMap: ConditionDataMap;
         conditions: ConditionV3;
     }, id: number, index: number, conditionType: "options" | "optionValidator" | "variables" | "prefillers" | "variableValidator" | "sections" | "documents"): any;
 }

package/dist/libs/ConditionsRunner.js

@@ -4,61 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var lplogic_1 = __importDefault(require("@legalplace/lplogic"));
+var DataPopulator_1 = __importDefault(require("./DataPopulator"));
 var ConditionsRunner = (function () {
     function ConditionsRunner(references, ovc) {
         this.references = references;
         this.ovc = ovc;
     }
-    ConditionsRunner.prototype.populateData = function (id, index, dataMap, withRelations) {
-        var _this = this;
-        if (withRelations === void 0) { withRelations = true; }
-        var data = {
-            o: {},
-            v: {}
-        };
-        dataMap.o.forEach(function (currentOptionId) {
-            var value = _this.ovc.options[currentOptionId];
-            var currentOptionParents = _this.references.relations.options[currentOptionId].parents;
-            var currentOptionRoot = currentOptionParents[currentOptionParents.length - 1];
-            var currentOptionRootRelations = currentOptionRoot
-                ? _this.references.relations.options[currentOptionId]
-                : undefined;
-            if (withRelations === true && currentOptionRootRelations) {
-                if (id === currentOptionId ||
-                    currentOptionRootRelations.children.options.includes(id) ||
-                    currentOptionRootRelations.dependants.includes(id))
-                    value = [value[index]];
-            }
-            data.o[currentOptionId] = value;
-        });
-        dataMap.v.forEach(function (currentVariableId) {
-            var variableReference = _this.references.variables[currentVariableId];
-            var value = _this.ovc.variables[currentVariableId];
-            var variableParents = _this.references.relations.variables[currentVariableId].parents;
-            var currentOptionId = variableParents[0];
-            var currentOptionParents = _this.references.relations.options[currentOptionId].parents;
-            var currentOptionRoot = currentOptionParents[currentOptionParents.length - 1];
-            var currentOptionRootRelations = currentOptionRoot
-                ? _this.references.relations.options[currentOptionId]
-                : undefined;
-            if (withRelations === true && currentOptionRootRelations) {
-                if (currentOptionRootRelations.children.options.includes(currentOptionId) ||
-                    currentOptionRootRelations.dependants.includes(currentOptionId)) {
-                    value = [value[index]];
-                }
-            }
-            var dataValue = value.map(function (v) {
-                return v === null ? "" : v;
-            });
-            if (variableReference.type === "number") {
-                dataValue = dataValue.map(function (v) {
-                    return typeof v === "number" ? v : parseFloat(v);
-                });
-            }
-            data.v[currentVariableId] = dataValue;
-        });
-        return data;
-    };
     ConditionsRunner.prototype.isOptionRelatedToOption = function (optionA, optionB) {
         var OptionBParents = this.references.relations.options[optionB].parents;
         var OptionBRoot = OptionBParents[OptionBParents.length - 1];
@@ -116,16 +67,16 @@ var ConditionsRunner = (function () {
             });
         var currentData;
         if (conditionType === "options" || conditionType === "optionValidator") {
-            currentData = this.populateData(id, index, condition.dataMap);
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
         }
         else if (conditionType === "variables" ||
             conditionType === "prefillers" ||
             conditionType === "variableValidator") {
             var dataId = this.references.relations.variables[id].parents[0];
-            currentData = this.populateData(dataId, index, condition.dataMap);
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, dataId, index).getData();
         }
         else if (conditionType === "sections" || conditionType === "documents") {
-            currentData = this.populateData(id, index, condition.dataMap, false);
+            currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
         }
         return lplogic_1.default(condition.conditions, currentData);
     };

package/dist/libs/DataPopulator.d.ts

@@ -0,0 +1,49 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+declare type OVC_TYPE = {
+    options: {
+        [key: string]: boolean[];
+    };
+    variables: {
+        [key: string]: (number | string)[];
+    };
+};
+declare class DataPopulator {
+    private references;
+    private ovc;
+    private conditionsRunner;
+    private id?;
+    private index?;
+    private dataMap;
+    private data;
+    constructor(conditionsRunner: ConditionsRunner, references: Types.ReferencesType, ovc: OVC_TYPE, dataMap: ConditionDataMap, id?: number, index?: number);
+    getData(): Readonly<ConditionData>;
+    private populateConditions;
+    private populateVariables;
+    private getVariableValues;
+    private getVariableRootParent;
+    private cleanArrayFromNullValues;
+    populateOptions(): void;
+    private getOptionInputs;
+    private getOptionRootParent;
+    private optionConditionValue;
+    private variableConditionValue;
+    private sectionConditionValue;
+}
+export interface ConditionDataMap {
+    o: number[];
+    v: number[];
+    c: {
+        o: number[];
+        s: number[];
+    };
+}
+export interface ConditionData {
+    o: Record<string, boolean[]>;
+    v: Record<string, (string | number)[]>;
+    c: {
+        o: Record<string, boolean[]>;
+        s: Record<string, boolean[]>;
+    };
+}
+export default DataPopulator;

package/dist/libs/DataPopulator.js

@@ -0,0 +1,153 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataPopulator = (function () {
+    function DataPopulator(conditionsRunner, references, ovc, dataMap, id, index) {
+        this.data = {
+            o: {},
+            v: {},
+            c: {
+                o: {},
+                s: {}
+            }
+        };
+        this.id = id;
+        this.ovc = ovc;
+        this.index = index;
+        this.dataMap = dataMap;
+        this.references = references;
+        this.conditionsRunner = conditionsRunner;
+        this.populateVariables();
+        this.populateOptions();
+        this.populateConditions();
+    }
+    DataPopulator.prototype.getData = function () {
+        return this.data;
+    };
+    DataPopulator.prototype.populateConditions = function () {
+        for (var i = 0; i < this.dataMap.c.s.length; i += 1) {
+            var sectionId = this.dataMap.c.s[i];
+            var sectionCondition = this.sectionConditionValue(sectionId);
+            this.data.c.s[sectionId] = [sectionCondition === true];
+        }
+        for (var i = 0; i < this.dataMap.c.o.length; i += 1) {
+            var optionId = this.dataMap.c.o[i];
+            var optionCondition = this.optionConditionValue(optionId);
+            this.data.c.o[optionId] =
+                optionCondition === undefined ? [false] : optionCondition;
+        }
+    };
+    DataPopulator.prototype.populateVariables = function () {
+        for (var i = 0; i < this.dataMap.v.length; i += 1) {
+            var variableId = this.dataMap.v[i];
+            var variableReference = this.references.variables[variableId];
+            var values = this.getVariableValues(variableId);
+            if (variableReference.type === "number") {
+                values = values.map(function (v) { return (typeof v === "number" ? v : parseFloat(v)); });
+            }
+            this.data.v[variableId] = __spreadArrays(values);
+        }
+    };
+    DataPopulator.prototype.getVariableValues = function (variableId) {
+        var conditions = this.variableConditionValue(variableId);
+        var value = this.ovc.variables[variableId];
+        if (this.id === undefined || this.index === undefined) {
+            return value;
+        }
+        var variableRootParent = this.getVariableRootParent(variableId);
+        var variableRootRelations = this.references.relations.options[variableRootParent];
+        if (variableRootRelations.children.options.includes(this.id) ||
+            variableRootRelations.dependants.includes(this.id) ||
+            this.id === variableRootParent) {
+            if (conditions !== undefined && conditions[this.index] === false)
+                return ["fAl$e"];
+            return [value[this.index]];
+        }
+        var cleanValues = this.cleanArrayFromNullValues(__spreadArrays(value));
+        if (conditions === undefined)
+            return cleanValues;
+        return cleanValues.map(function (currentValue, index) {
+            if (conditions[index] === false)
+                return "fAl$e";
+            return currentValue;
+        });
+    };
+    DataPopulator.prototype.getVariableRootParent = function (variableId) {
+        var variableParents = this.references.relations.variables[variableId]
+            .parents;
+        return variableParents[variableParents.length - 1];
+    };
+    DataPopulator.prototype.cleanArrayFromNullValues = function (arr) {
+        return arr.map(function (v) { return (v === null ? "" : v); });
+    };
+    DataPopulator.prototype.populateOptions = function () {
+        for (var i = 0; i < this.dataMap.o.length; i += 1) {
+            var optionId = this.dataMap.o[i];
+            var inputs = this.getOptionInputs(optionId);
+            this.data.o[optionId] = __spreadArrays(inputs);
+        }
+    };
+    DataPopulator.prototype.getOptionInputs = function (optionId) {
+        var conditions = this.optionConditionValue(optionId);
+        var inputs = this.ovc.options[optionId];
+        if (this.id === undefined || this.index === undefined) {
+            return inputs;
+        }
+        var optionRootParent = this.getOptionRootParent(optionId);
+        var 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 [inputs[this.index]];
+        }
+        if (conditions === undefined)
+            return inputs;
+        return inputs.map(function (value, index) {
+            if (conditions[index] === false)
+                return false;
+            return value;
+        });
+    };
+    DataPopulator.prototype.getOptionRootParent = function (optionId) {
+        var optionParents = this.references.relations.options[optionId].parents;
+        return optionParents.length > 0
+            ? optionParents[optionParents.length - 1]
+            : optionId;
+    };
+    DataPopulator.prototype.optionConditionValue = function (optionId) {
+        var _this = this;
+        var conditions = this.references.conditions.options[optionId];
+        if (conditions === undefined)
+            return undefined;
+        var inputs = this.ovc.options[optionId];
+        return inputs.map(function (input, index) {
+            return _this.conditionsRunner.executeCondition(conditions, optionId, index, "options");
+        });
+    };
+    DataPopulator.prototype.variableConditionValue = function (variableId) {
+        var _this = this;
+        var conditions = this.references.conditions.variables[variableId];
+        if (conditions === undefined)
+            return undefined;
+        var inputs = this.ovc.variables[variableId];
+        return inputs.map(function (input, index) {
+            return _this.conditionsRunner.executeCondition(conditions, variableId, index, "variables");
+        });
+    };
+    DataPopulator.prototype.sectionConditionValue = function (sectionId) {
+        var conditions = this.references.conditions.sections.main[sectionId];
+        if (conditions === undefined)
+            return undefined;
+        return this.conditionsRunner.executeCondition(conditions, 0, 0, "sections");
+    };
+    return DataPopulator;
+}());
+exports.default = DataPopulator;

package/dist/libs/OutputParser.js

@@ -39,6 +39,7 @@ exports.parseOutputWithVariables = function (output, variables, autonums) {
         parsedOutput = parsedOutput.replace(new RegExp("\\[var:" + variableId + "\\]", "g"), value);
     });
     parsedOutput = parsedOutput.replace(/\[\[PAGE_BREAK\]\]/gi, '<p class="pagebreak"><!-- pagebreak --></p>');
+    parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, "");
     autonums.forEach(function (currentAn) {
         if (currentAn[3] === null)
             parsedOutput = parsedOutput.replace("[" + currentAn[0] + ":" + currentAn[1] + "]", "<span class=\"" + currentAn[0] + "\">" + currentAn[2] + "</span>");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/prerenderx",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "PrerenderX",
   "main": "dist/index.js",
   "repository": "https://git.legalplace.eu/legalplace/prerenderx",

package/src/libs/ConditionsRunner.ts

@@ -2,6 +2,7 @@
 import LpLogic from "@legalplace/lplogic";
 import { Types } from "@legalplace/referencesparser";
 import { ConditionV3 } from "@legalplace/models-v3-types";
+import DataPopulator, { ConditionDataMap } from "./DataPopulator";
 
 type OVC_TYPE = {
   options: {
@@ -12,11 +13,6 @@ type OVC_TYPE = {
   };
 };
 
-interface ConditionDataMap {
-  o: number[];
-  v: number[];
-}
-
 interface ConditionData {
   o: Record<string, boolean[]>;
   v: Record<string, (string | number)[]>;
@@ -32,94 +28,6 @@ class ConditionsRunner {
     this.ovc = ovc;
   }
 
-  private populateData(
-    id: number,
-    index: number,
-    dataMap: ConditionDataMap,
-    withRelations = true
-  ) {
-    const data: ConditionData = {
-      o: {},
-      v: {}
-    };
-
-    // Populating options
-    dataMap.o.forEach(currentOptionId => {
-      // Getting option value
-      let value = this.ovc.options[currentOptionId];
-
-      // Getting current relations
-      const currentOptionParents = this.references.relations.options[
-        currentOptionId
-      ].parents;
-      const currentOptionRoot =
-        currentOptionParents[currentOptionParents.length - 1];
-      const currentOptionRootRelations = currentOptionRoot
-        ? this.references.relations.options[currentOptionId]
-        : undefined;
-
-      // Checking if current option is related to the option that changed
-      if (withRelations === true && currentOptionRootRelations) {
-        if (
-          id === currentOptionId ||
-          currentOptionRootRelations.children.options.includes(id) ||
-          currentOptionRootRelations.dependants.includes(id)
-        )
-          value = [value[index]];
-      }
-
-      data.o[currentOptionId] = value;
-    });
-
-    // Populating variables
-    dataMap.v.forEach(currentVariableId => {
-      // Getting variable data
-      const variableReference = this.references.variables[currentVariableId];
-      let value = this.ovc.variables[currentVariableId];
-      const variableParents = this.references.relations.variables[
-        currentVariableId
-      ].parents;
-      const currentOptionId = variableParents[0];
-
-      // Getting current relations
-      const currentOptionParents = this.references.relations.options[
-        currentOptionId
-      ].parents;
-      const currentOptionRoot =
-        currentOptionParents[currentOptionParents.length - 1];
-      const currentOptionRootRelations = currentOptionRoot
-        ? this.references.relations.options[currentOptionId]
-        : undefined;
-
-      // Checking if current option is related to the option that changed
-      if (withRelations === true && currentOptionRootRelations) {
-        if (
-          currentOptionRootRelations.children.options.includes(
-            currentOptionId
-          ) ||
-          currentOptionRootRelations.dependants.includes(currentOptionId)
-        ) {
-          value = [value[index]];
-        }
-      }
-
-      let dataValue: (string | number)[] = value.map(v =>
-        v === null ? "" : v
-      );
-
-      // If variable is of type number
-      if (variableReference.type === "number") {
-        dataValue = dataValue.map(v =>
-          typeof v === "number" ? v : parseFloat(v)
-        );
-      }
-
-      data.v[currentVariableId] = dataValue;
-    });
-
-    return data;
-  }
-
   isOptionRelatedToOption(optionA: number, optionB: number): boolean {
     // Getting B relations
     const OptionBParents = this.references.relations.options[optionB].parents;
@@ -196,7 +104,7 @@ class ConditionsRunner {
 
   executeCondition(
     condition: {
-      dataMap: { o: number[]; v: number[] };
+      dataMap: ConditionDataMap;
       conditions: ConditionV3;
     },
     id: number,
@@ -218,16 +126,37 @@ class ConditionsRunner {
     // Populating Data
     let currentData;
     if (conditionType === "options" || conditionType === "optionValidator") {
-      currentData = this.populateData(id, index, condition.dataMap);
+      currentData = new DataPopulator(
+        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 = this.populateData(dataId, index, condition.dataMap);
+      currentData = new DataPopulator(
+        this,
+        this.references,
+        this.ovc,
+        condition.dataMap,
+        dataId,
+        index
+      ).getData();
     } else if (conditionType === "sections" || conditionType === "documents") {
-      currentData = this.populateData(id, index, condition.dataMap, false);
+      currentData = new DataPopulator(
+        this,
+        this.references,
+        this.ovc,
+        condition.dataMap,
+        id,
+        index
+      ).getData();
     }
 
     return LpLogic(condition.conditions, currentData);

package/src/libs/DataPopulator.ts

@@ -0,0 +1,291 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+
+type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[];
+  };
+  variables: {
+    [key: string]: (number | string)[];
+  };
+};
+
+class DataPopulator {
+  private references: Types.ReferencesType;
+
+  private ovc: OVC_TYPE;
+
+  private conditionsRunner: ConditionsRunner;
+
+  private id?: number;
+
+  private index?: number;
+
+  private dataMap: ConditionDataMap;
+
+  private data: ConditionData = {
+    o: {},
+    v: {},
+    c: {
+      o: {},
+      s: {}
+    }
+  };
+
+  constructor(
+    conditionsRunner: ConditionsRunner,
+    references: Types.ReferencesType,
+    ovc: OVC_TYPE,
+    dataMap: ConditionDataMap,
+    id?: number,
+    index?: number
+  ) {
+    this.id = id;
+    this.ovc = ovc;
+    this.index = index;
+    this.dataMap = dataMap;
+    this.references = references;
+    this.conditionsRunner = conditionsRunner;
+
+    // Populating variables
+    this.populateVariables();
+
+    // Populating options
+    this.populateOptions();
+
+    // Populating conditions
+    this.populateConditions();
+  }
+
+  /**
+   * Returns resulting data object
+   */
+  public getData(): Readonly<ConditionData> {
+    return this.data;
+  }
+
+  private populateConditions(): void {
+    // Sections
+    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 === true];
+    }
+
+    // Options
+    for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
+      const optionId = this.dataMap.c.o[i];
+      const optionCondition = this.optionConditionValue(optionId);
+      this.data.c.o[optionId] =
+        optionCondition === undefined ? [false] : optionCondition;
+    }
+  }
+
+  /**
+   * Populates variables according to the current dataMap object
+   */
+  private populateVariables(): void {
+    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);
+
+      // If variable is of type number
+      if (variableReference.type === "number") {
+        values = values.map(v => (typeof v === "number" ? v : parseFloat(v)));
+      }
+
+      // Adding variables
+      this.data.v[variableId] = [...values];
+    }
+  }
+
+  /**
+   * Returns a give variables value
+   * @param variableId Variable's id
+   */
+  private getVariableValues(variableId: number): Readonly<(string | number)[]> {
+    const conditions = this.variableConditionValue(variableId);
+    const value = this.ovc.variables[variableId];
+    if (this.id === undefined || this.index === undefined) {
+      return value;
+    }
+
+    // Getting variable parent option
+    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
+    ) {
+      // TODO: Replace fAl$e with a safer solution
+      if (conditions !== undefined && conditions[this.index] === false)
+        return ["fAl$e"];
+      return [value[this.index]];
+    }
+
+    const cleanValues = this.cleanArrayFromNullValues([...value]);
+
+    if (conditions === undefined) return cleanValues;
+
+    return cleanValues.map((currentValue, index) => {
+      if (conditions[index] === false) return "fAl$e";
+      return currentValue;
+    });
+  }
+
+  /**
+   * Return a given variable root option relations
+   * @param variableId Variable's id
+   */
+  private getVariableRootParent(variableId: number) {
+    const variableParents = this.references.relations.variables[variableId]
+      .parents;
+    return variableParents[variableParents.length - 1];
+  }
+
+  /**
+   * Cleans values array from any null value by replacing it
+   * with an empty string
+   * @param arr Values array
+   */
+  private cleanArrayFromNullValues(
+    arr: (string | number | null)[]
+  ): (string | number)[] {
+    return arr.map(v => (v === null ? "" : v));
+  }
+
+  /**
+   * Populates options data object accodring to current dataMap object
+   */
+  populateOptions() {
+    for (let i = 0; i < this.dataMap.o.length; i += 1) {
+      const optionId = this.dataMap.o[i];
+      const inputs = this.getOptionInputs(optionId);
+
+      // Adding option
+      this.data.o[optionId] = [...inputs];
+    }
+  }
+
+  /**
+   * Returns a give option's inputs
+   * @param optionId Option's id
+   */
+  private getOptionInputs(optionId: number): Readonly<boolean[]> {
+    const conditions = this.optionConditionValue(optionId);
+    const inputs = this.ovc.options[optionId];
+    if (this.id === undefined || this.index === undefined) {
+      return inputs;
+    }
+
+    // Getting variable parent option
+    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 [inputs[this.index]];
+    }
+
+    if (conditions === undefined) return inputs;
+
+    return inputs.map((value, index) => {
+      if (conditions[index] === false) return false;
+      return value;
+    });
+  }
+
+  /**
+   * Returns option's root parent
+   * @param optionId Root parent
+   */
+  private getOptionRootParent(optionId: number) {
+    const optionParents = this.references.relations.options[optionId].parents;
+    return optionParents.length > 0
+      ? optionParents[optionParents.length - 1]
+      : optionId;
+  }
+
+  /**
+   * Calculates option's condition
+   */
+  private optionConditionValue(optionId: number) {
+    // Getting option conditions
+    const conditions = this.references.conditions.options[optionId];
+    if (conditions === undefined) return undefined;
+
+    // Getting option inputs length
+    const inputs = this.ovc.options[optionId];
+
+    return inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(
+        conditions,
+        optionId,
+        index,
+        "options"
+      );
+    });
+  }
+
+  /**
+   * Calculates variable's condition
+   */
+  private variableConditionValue(variableId: number) {
+    // Getting variable conditions
+    const conditions = this.references.conditions.variables[variableId];
+    if (conditions === undefined) return undefined;
+
+    // Getting variable inputs length
+    const inputs = this.ovc.variables[variableId];
+
+    return inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(
+        conditions,
+        variableId,
+        index,
+        "variables"
+      );
+    });
+  }
+
+  /**
+   * Calculates section's condition
+   */
+  private sectionConditionValue(sectionId: number) {
+    // Getting section conditions
+    const conditions = this.references.conditions.sections.main[sectionId];
+    if (conditions === undefined) return undefined;
+
+    return this.conditionsRunner.executeCondition(conditions, 0, 0, "sections");
+  }
+}
+
+export interface ConditionDataMap {
+  o: number[];
+  v: number[];
+  c: {
+    o: number[];
+    s: number[];
+  };
+}
+
+export interface ConditionData {
+  o: Record<string, boolean[]>;
+  v: Record<string, (string | number)[]>;
+  c: {
+    o: Record<string, boolean[]>;
+    s: Record<string, boolean[]>;
+  };
+}
+
+export default DataPopulator;

package/src/libs/OutputParser.ts

@@ -104,6 +104,9 @@ export const parseOutputWithVariables: parseOutputT = (
     '<p class="pagebreak"><!-- pagebreak --></p>'
   );
 
+  // Cleaning BLURS
+  parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, "");
+
   // Inserting autonums
   autonums.forEach(currentAn => {
     if (currentAn[3] === null)