@legalplace/tagextractor 1.0.0 → 1.1.0

package/.eslintrc

@@ -38,7 +38,14 @@
     "import/prefer-default-export": "warn",
     "camelcase": "error",
     "no-undef": 0,
-    "no-dupe-class-members": "off"
+    "no-dupe-class-members": "off",
+    "import/extensions": ["error", "ignorePackages", {
+      "js": "never",
+      "jsx": "never",
+      "ts": "never",
+      "tsx": "never",
+      "mjs": "never"
+    }]
   },
 
 

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import TagsExtractor from './libs/Extractor';
-export default TagsExtractor;
+import TagExtractor from './libs/Extractor';
+export default TagExtractor;

package/dist/libs/DataPopulator.js

@@ -57,9 +57,7 @@ var DataPopulator = (function () {
         }
         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 (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]];
@@ -75,9 +73,7 @@ var DataPopulator = (function () {
         }
         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 (variableRootRelations.children.options.includes(this.id) || variableRootRelations.dependants.includes(this.id) || this.id === variableRootParent) {
             return [conditions[this.index]];
         }
         return conditions;

package/dist/libs/Extractor.d.ts

@@ -1,8 +1,8 @@
-import { ModelV3 } from "@legalplace/models-v3-types";
-import InputsType from "../types/inputs.type";
-import OvcType from "../types/ovc.type";
-import TagsType from "../types/tags.type";
-declare class TagsExtractor {
+import { ModelV3 } from '@legalplace/models-v3-types';
+import InputsType from '../types/inputs.type';
+import OvcType from '../types/ovc.type';
+import TagsType from '../types/tags.type';
+declare class TagExtractor {
     private references;
     private inputs;
     private conditionsRunner;
@@ -12,6 +12,11 @@ declare class TagsExtractor {
     private extractFromOptions;
     private extractFromVariables;
     private optionConditionValue;
-    private variableConditionValue;
+    isVariableDisplayed(id: number, index: number): boolean;
+    isOptionDisplayed(id: number, index: number): boolean;
+    private getVariableCondition;
+    private getOptionCondition;
+    private getSectionCondition;
+    private getOptionParentSection;
 }
-export default TagsExtractor;
+export default TagExtractor;

package/dist/libs/Extractor.js

@@ -1,4 +1,11 @@
 "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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,8 +13,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var referencesparser_1 = require("@legalplace/referencesparser");
 var ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
 var OvcConverter_1 = __importDefault(require("./OvcConverter"));
-var TagsExtractor = (function () {
-    function TagsExtractor(model, ovc) {
+var TagExtractor = (function () {
+    function TagExtractor(model, ovc) {
         this.tags = {
             options: {},
             variables: {}
@@ -18,29 +25,28 @@ var TagsExtractor = (function () {
         this.extractFromOptions();
         this.extractFromVariables();
     }
-    Object.defineProperty(TagsExtractor.prototype, "getTags", {
+    Object.defineProperty(TagExtractor.prototype, "getTags", {
         get: function () {
             return this.tags;
         },
         enumerable: false,
         configurable: true
     });
-    TagsExtractor.prototype.extractFromOptions = function () {
+    TagExtractor.prototype.extractFromOptions = function () {
         var _this = this;
         Object.keys(this.references.options).forEach(function (id) {
             var _a = _this.references.options[id].meta, tags = _a.tags, label = _a.label;
             if (Array.isArray(tags) && tags.length > 0) {
-                var conditions_1 = _this.optionConditionValue(parseInt(id, 10));
                 _this.inputs.options[id].forEach(function (v, index) {
                     tags.forEach(function (tag) {
                         if (_this.tags.options[tag] === undefined)
                             _this.tags.options[tag] = [];
-                        console.log(conditions_1[index], conditions_1);
                         _this.tags.options[tag].push({
                             id: parseInt(id, 10),
                             index: index,
                             label: label,
-                            condition: conditions_1[index],
+                            condition: _this.getOptionCondition(parseInt(id, 10), index),
+                            visible: _this.isOptionDisplayed(parseInt(id, 10), index),
                             value: _this.inputs.options[id][index]
                         });
                     });
@@ -48,12 +54,11 @@ var TagsExtractor = (function () {
             }
         });
     };
-    TagsExtractor.prototype.extractFromVariables = function () {
+    TagExtractor.prototype.extractFromVariables = function () {
         var _this = this;
         Object.keys(this.references.variables).forEach(function (id) {
             var _a = _this.references.variables[id], tags = _a.tags, label = _a.label;
             if (Array.isArray(tags) && tags.length > 0) {
-                var conditions_2 = _this.variableConditionValue(parseInt(id, 10));
                 _this.inputs.variables[id].forEach(function (v, index) {
                     tags.forEach(function (tag) {
                         if (_this.tags.variables[tag] === undefined)
@@ -62,7 +67,8 @@ var TagsExtractor = (function () {
                             id: parseInt(id, 10),
                             index: index,
                             label: label,
-                            condition: conditions_2[index],
+                            condition: _this.getVariableCondition(parseInt(id, 10), index) !== false,
+                            visible: _this.isVariableDisplayed(parseInt(id, 10), index),
                             value: _this.inputs.variables[id][index]
                         });
                     });
@@ -70,7 +76,7 @@ var TagsExtractor = (function () {
             }
         });
     };
-    TagsExtractor.prototype.optionConditionValue = function (optionId) {
+    TagExtractor.prototype.optionConditionValue = function (optionId) {
         var _this = this;
         var conditions = this.references.conditions.options[optionId];
         var inputs = this.inputs.options[optionId];
@@ -80,17 +86,50 @@ var TagsExtractor = (function () {
             return _this.conditionsRunner.executeCondition(conditions, optionId, index, 'options');
         });
     };
-    TagsExtractor.prototype.variableConditionValue = function (variableId) {
+    TagExtractor.prototype.isVariableDisplayed = function (id, index) {
+        var _a;
+        var variableCondition = this.getVariableCondition(id, index);
+        var variableParents = ((_a = this.references.relations.variables[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        var parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index);
+        return [variableCondition, parentOptionIsDisplayed].filter(function (c) { return c !== true; }).length === 0;
+    };
+    TagExtractor.prototype.isOptionDisplayed = function (id, index) {
         var _this = this;
-        var conditions = this.references.conditions.variables[variableId];
-        var inputs = this.inputs.variables[variableId];
-        if (conditions === undefined)
-            return inputs.map(function () { return true; });
-        var result = inputs.map(function (input, index) {
-            return _this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables');
+        var _a;
+        var optionCondition = this.getOptionCondition(id, index);
+        var optionParents = ((_a = this.references.relations.options[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        var parentsConditions = optionParents.map(function (optionId) {
+            return _this.getOptionCondition(optionId, index) !== false;
+        });
+        var parentsInputs = optionParents.map(function (optionId) {
+            return _this.inputs.options[optionId][index];
         });
-        return result;
+        var parentSectionId = this.getOptionParentSection(id);
+        var parentSectionCondition = this.getSectionCondition(parentSectionId) !== false;
+        return __spreadArrays([optionCondition, parentSectionCondition], parentsConditions, parentsInputs).filter(function (c) { return c !== true; }).length === 0;
+    };
+    TagExtractor.prototype.getVariableCondition = function (id, index) {
+        var conditionObject = this.references.conditions.variables[id];
+        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'variables');
+    };
+    TagExtractor.prototype.getOptionCondition = function (id, index) {
+        var conditionObject = this.references.conditions.options[id];
+        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'options');
+    };
+    TagExtractor.prototype.getSectionCondition = function (id) {
+        var conditionObject = this.references.conditions.sections.main[id];
+        return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, 0, 'sections');
+    };
+    TagExtractor.prototype.getOptionParentSection = function (id) {
+        var parents = this.references.relations.options[id].parents;
+        var rootId = parents.length > 0 ? parents[parents.length - 1] : id;
+        var sections = Object.values(this.references.sections.main);
+        for (var i = 0; i < sections.length; i += 1) {
+            if (sections[i].options.includes(rootId))
+                return sections[i].id;
+        }
+        throw new Error("Cannot find parent section for option " + id + " (Root option id: " + rootId + ")");
     };
-    return TagsExtractor;
+    return TagExtractor;
 }());
-exports.default = TagsExtractor;
+exports.default = TagExtractor;

package/dist/libs/OvcConverter.js

@@ -36,14 +36,11 @@ var OvcConverter = (function () {
                     var occurences_1 = currentOption.length;
                     inputs.options = __assign(__assign({}, inputs.options), _this.pushStaticChildren(inputs.options, id, occurences_1, references));
                     currentOption.forEach(function (childId, index) {
-                        var sanitizedId = typeof childId === 'string' && childId.split('_').length > 0
-                            ? childId.split('_')[0]
-                            : childId;
+                        var sanitizedId = typeof childId === 'string' && childId.split('_').length > 0 ? childId.split('_')[0] : childId;
                         if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
                             inputs.options[id] = new Array(occurences_1).fill(false);
                         }
-                        if (typeof sanitizedId === 'string' &&
-                            sanitizedId.trim().length === 0) {
+                        if (typeof sanitizedId === 'string' && sanitizedId.trim().length === 0) {
                             return;
                         }
                         if (!Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)) {
@@ -54,8 +51,7 @@ var OvcConverter = (function () {
                     });
                 }
                 else {
-                    if (typeof currentOption === 'string' &&
-                        currentOption.trim().length === 0)
+                    if (typeof currentOption === 'string' && currentOption.trim().length === 0)
                         return;
                     inputs.options[currentOption] = [true];
                 }

package/dist/types/tags.type.d.ts

@@ -7,6 +7,7 @@ export interface OptionTagType {
     index: number;
     label: string;
     condition: boolean;
+    visible: boolean;
     value: boolean;
 }
 export interface VariableTagType {
@@ -14,6 +15,7 @@ export interface VariableTagType {
     index: number;
     label: string;
     condition: boolean;
+    visible: boolean;
     value: string | number;
 }
 export default TagsType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/tagextractor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "TagExtractor",
   "main": "dist/index.js",
   "repository": "https://git.legalplace.eu/legalplace/tagextractor",

package/src/index.ts

@@ -1,3 +1,3 @@
-import TagsExtractor from './libs/Extractor'
+import TagExtractor from './libs/Extractor'
 
-export default TagsExtractor;
+export default TagExtractor

package/src/libs/DataPopulator.ts

@@ -69,7 +69,7 @@ class DataPopulator {
     // Options
     for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
       const optionId = this.dataMap.c.o[i]
-      const optionCondition = [...this.getOptionConditions(optionId)];
+      const optionCondition = [...this.getOptionConditions(optionId)]
       this.data.c.o[optionId] = optionCondition === undefined ? [false] : optionCondition
     }
 
@@ -80,31 +80,27 @@ class DataPopulator {
       this.data.c.v[variableId] = variableCondition === undefined ? [false] : variableCondition
     }
   }
-/**
+
+  /**
    * Returns a give option's conditions
    * @param optionId Option's id
    */
   private getOptionConditions(optionId: number): Readonly<boolean[]> {
-    const conditions = this.optionConditionValue(optionId);
-    if (conditions === undefined) return [true];
+    const conditions = this.optionConditionValue(optionId)
+    if (conditions === undefined) return [true]
     if (this.id === undefined || this.index === undefined) {
-      return conditions;
+      return conditions
     }
 
     // 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 [conditions[this.index]];
+    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;
+    return conditions
   }
 
   /**
@@ -112,24 +108,20 @@ class DataPopulator {
    * @param variableId Variable's id
    */
   private getVariablesConditions(variableId: number): Readonly<boolean[]> {
-    const conditions = this.variableConditionValue(variableId);
-    if (conditions === undefined) return [true];
+    const conditions = this.variableConditionValue(variableId)
+    if (conditions === undefined) return [true]
     if (this.id === undefined || this.index === undefined) {
-      return conditions;
+      return conditions
     }
 
     // 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
-    ) {
-      return [conditions[this.index]];
+    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;
+    return conditions
   }
 
   /**

package/src/libs/Extractor.ts

@@ -1,15 +1,15 @@
-import { ModelV3 } from "@legalplace/models-v3-types";
+import { ModelV3 } from '@legalplace/models-v3-types'
 import { ReferencesParser, Types } from '@legalplace/referencesparser'
-import InputsType from "../types/inputs.type";
-import OvcType from "../types/ovc.type";
-import TagsType from "../types/tags.type";
-import ConditionsRunner from "./ConditionsRunner";
-import OvcConverter from "./OvcConverter";
+import InputsType from '../types/inputs.type'
+import OvcType from '../types/ovc.type'
+import TagsType from '../types/tags.type'
+import ConditionsRunner from './ConditionsRunner'
+import OvcConverter from './OvcConverter'
 
-class TagsExtractor {
-  private references: Types.ReferencesType;
+class TagExtractor {
+  private references: Types.ReferencesType
 
-  private inputs: InputsType;
+  private inputs: InputsType
 
   private conditionsRunner: ConditionsRunner
 
@@ -26,13 +26,13 @@ class TagsExtractor {
     this.inputs = OvcConverter.isOptionsVariables(ovc) ? ovc : OvcConverter.convertToOptionsVariables(ovc, this.references)
 
     // Initiaing Conditions runner
-    this.conditionsRunner = new ConditionsRunner(this.references, this.inputs);
+    this.conditionsRunner = new ConditionsRunner(this.references, this.inputs)
 
     // Extracting tags from options
-    this.extractFromOptions();
+    this.extractFromOptions()
 
     // Extracting tags from variables
-    this.extractFromVariables();
+    this.extractFromVariables()
   }
 
   public get getTags() {
@@ -44,32 +44,23 @@ class TagsExtractor {
    */
   private extractFromOptions() {
     Object.keys(this.references.options).forEach(id => {
-      const {tags, label} = this.references.options[id].meta
+      const { tags, label } = this.references.options[id].meta
 
-      if(Array.isArray(tags) && tags.length > 0) {
-
-        // Getting condition
-        const conditions = this.optionConditionValue(parseInt(id, 10))
-        
+      if (Array.isArray(tags) && tags.length > 0) {
         this.inputs.options[id].forEach((v, index) => {
-
-          tags.forEach((tag) => {
-            if(this.tags.options[tag] === undefined) this.tags.options[tag] = []
-
-            console.log(conditions[index], conditions)
+          tags.forEach(tag => {
+            if (this.tags.options[tag] === undefined) this.tags.options[tag] = []
             this.tags.options[tag].push({
               id: parseInt(id, 10),
               index,
-              label: label,
-              condition: conditions[index],
+              label,
+              condition: this.getOptionCondition(parseInt(id, 10), index),
+              visible: this.isOptionDisplayed(parseInt(id, 10), index),
               value: this.inputs.options[id][index]
             })
           })
-
         })
-
       }
-
     })
   }
 
@@ -78,34 +69,26 @@ class TagsExtractor {
    */
   private extractFromVariables() {
     Object.keys(this.references.variables).forEach(id => {
-      const {tags, label} = this.references.variables[id]
-
-      if(Array.isArray(tags) && tags.length > 0) {
+      const { tags, label } = this.references.variables[id]
 
-        // Getting condition
-        const conditions = this.variableConditionValue(parseInt(id, 10))
-        
+      if (Array.isArray(tags) && tags.length > 0) {
         this.inputs.variables[id].forEach((v, index) => {
-
-          tags.forEach((tag) => {
-            if(this.tags.variables[tag] === undefined) this.tags.variables[tag] = []
+          tags.forEach(tag => {
+            if (this.tags.variables[tag] === undefined) this.tags.variables[tag] = []
             this.tags.variables[tag].push({
               id: parseInt(id, 10),
               index,
-              label: label,
-              condition: conditions[index],
+              label,
+              condition: this.getVariableCondition(parseInt(id, 10), index) !== false,
+              visible: this.isVariableDisplayed(parseInt(id, 10), index),
               value: this.inputs.variables[id][index]
             })
           })
-
         })
-
       }
-
     })
   }
 
-
   /**
    * Calculates option's condition
    */
@@ -115,7 +98,7 @@ class TagsExtractor {
 
     // Getting option inputs length
     const inputs = this.inputs.options[optionId]
-    
+
     if (conditions === undefined) return inputs.map(() => true)
 
     return inputs.map((input, index) => {
@@ -124,23 +107,88 @@ class TagsExtractor {
   }
 
   /**
-   * Calculates variable's condition
+   * Checks whether a variable is displayed at a given index
+   * @param id Variable's ID
+   * @param index Index
    */
-  private variableConditionValue(variableId: number) {
-    // Getting variable conditions
-    const conditions = this.references.conditions.variables[variableId]
+  isVariableDisplayed(id: number, index: number) {
+    // Getting variable's conditions & executing it if any
+    const variableCondition = this.getVariableCondition(id, index)
+    const variableParents = this.references.relations.variables[id]?.parents || []
+    const parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index)
 
-    // Getting variable inputs length
-    const inputs = this.inputs.variables[variableId]
-
-    if (conditions === undefined) return inputs.map(() => true)
+    return [variableCondition, parentOptionIsDisplayed].filter(c => c !== true).length === 0
+  }
 
-    const result = inputs.map((input, index) => {
-      return this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables')
+  /**
+   * Checks whether an option is displayed at a given index
+   * @param id Option's ID
+   * @param index Index
+   */
+  isOptionDisplayed(id: number, index: number) {
+    // Getting variable's conditions & executing it if any
+    const optionCondition = this.getOptionCondition(id, index)
+    const optionParents = this.references.relations.options[id]?.parents || []
+    const parentsConditions = optionParents.map(optionId => {
+      return this.getOptionCondition(optionId, index) !== false
     })
+    const parentsInputs = optionParents.map(optionId => {
+      return this.inputs.options[optionId][index]
+    })
+    const parentSectionId = this.getOptionParentSection(id)
+    const parentSectionCondition = this.getSectionCondition(parentSectionId) !== false
+
+    return [optionCondition, parentSectionCondition, ...parentsConditions, ...parentsInputs].filter(c => c !== true).length === 0
+  }
+
+  /**
+   * Returns a variable's conditions
+   * @param id Variable's id
+   * @param index Variable's index
+   */
+  private getVariableCondition(id: number, index: number) {
+    const conditionObject = this.references.conditions.variables[id]
+    return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'variables')
+  }
+
+  /**
+   * Returns an option's conditions
+   * @param id Option's id
+   * @param index Option's index
+   */
+  private getOptionCondition(id: number, index: number) {
+    const conditionObject = this.references.conditions.options[id]
+    return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, index, 'options')
+  }
+
+  /**
+   * Returns a section's conditions
+   * @param id Section's id
+   */
+  private getSectionCondition(id: number) {
+    const conditionObject = this.references.conditions.sections.main[id]
+    return conditionObject === undefined ? true : this.conditionsRunner.executeCondition(conditionObject, id, 0, 'sections')
+  }
+
+  /**
+   * Returns option's parent section
+   * @param id Option's id
+   */
+  private getOptionParentSection(id: number) {
+    const { parents } = this.references.relations.options[id]
+
+    // Getting root option id
+    const rootId = parents.length > 0 ? parents[parents.length - 1] : id
+
+    // Looking for section
+    const sections = Object.values(this.references.sections.main)
+
+    for (let i = 0; i < sections.length; i += 1) {
+      if (sections[i].options.includes(rootId)) return sections[i].id
+    }
 
-    return result
+    throw new Error(`Cannot find parent section for option ${id} (Root option id: ${rootId})`)
   }
 }
 
-export default TagsExtractor
+export default TagExtractor

package/src/libs/OvcConverter.ts

@@ -1,131 +1,101 @@
 import { Types } from '@legalplace/referencesparser'
-import InputsType from '../types/inputs.type';
-import OvcType from '../types/ovc.type';
-
+import InputsType from '../types/inputs.type'
+import OvcType from '../types/ovc.type'
 
 class OvcConverter {
-  public convertToOptionsVariables(
-    ovc: OvcType,
-    references: Types.ReferencesType
-  ) {
+  public convertToOptionsVariables(ovc: OvcType, references: Types.ReferencesType) {
     const inputs: InputsType = {
       options: {},
       variables: {}
     }
 
-if (typeof ovc !== 'object') return inputs;
+    if (typeof ovc !== 'object') return inputs
 
     // Reading options
     if (typeof ovc.o === 'object') {
       Object.keys(ovc.o).forEach(id => {
-        const currentOption = ovc.o[id];
+        const currentOption = ovc.o[id]
 
         // If it's a multiple
         if (Array.isArray(currentOption)) {
-          const occurences = currentOption.length;
+          const occurences = currentOption.length
           // Adding static childrens
           inputs.options = {
             ...inputs.options,
-            ...this.pushStaticChildren(
-              inputs.options,
-              id,
-              occurences,
-              references
-            )
-          };
+            ...this.pushStaticChildren(inputs.options, id, occurences, references)
+          }
           currentOption.forEach((childId, index) => {
-            const sanitizedId =
-              typeof childId === 'string' && childId.split('_').length > 0
-                ? childId.split('_')[0]
-                : childId;
+            const sanitizedId = typeof childId === 'string' && childId.split('_').length > 0 ? childId.split('_')[0] : childId
 
             // Making sure the input exist
             if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
-              inputs.options[id] = new Array(occurences).fill(false);
+              inputs.options[id] = new Array(occurences).fill(false)
             }
 
             // Making sure the childId is not empty
-            if (
-              typeof sanitizedId === 'string' &&
-              sanitizedId.trim().length === 0
-            ) {
-              return;
+            if (typeof sanitizedId === 'string' && sanitizedId.trim().length === 0) {
+              return
             }
 
             // Creating input if it doesn't exist
-            if (
-              !Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)
-            ) {
-              inputs.options[sanitizedId] = new Array(occurences).fill(false);
+            if (!Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)) {
+              inputs.options[sanitizedId] = new Array(occurences).fill(false)
             }
 
             // Adding static childrens
             inputs.options = {
               ...inputs.options,
-              ...this.pushStaticChildren(
-                inputs.options,
-                sanitizedId,
-                occurences,
-                references
-              )
-            };
+              ...this.pushStaticChildren(inputs.options, sanitizedId, occurences, references)
+            }
 
             // Setting current index to true
-            inputs.options[sanitizedId][index] = true;
-          });
+            inputs.options[sanitizedId][index] = true
+          })
         } else {
-          if (
-            typeof currentOption === 'string' &&
-            currentOption.trim().length === 0
-          )
-            return;
-          inputs.options[currentOption] = [true];
+          if (typeof currentOption === 'string' && currentOption.trim().length === 0) return
+          inputs.options[currentOption] = [true]
         }
-      });
+      })
     }
 
     // Reading checkboxes
     if (typeof ovc.c === 'object') {
       Object.keys(ovc.c).forEach(id => {
-        const currentCheckbox = ovc.c[id];
-        if (typeof id === 'string' && id.trim().length === 0) return;
+        const currentCheckbox = ovc.c[id]
+        if (typeof id === 'string' && id.trim().length === 0) return
         // If it's a multiple
         if (Array.isArray(currentCheckbox)) {
-          inputs.options[id] = currentCheckbox;
+          inputs.options[id] = currentCheckbox
         } else {
-          inputs.options[id] = [currentCheckbox];
+          inputs.options[id] = [currentCheckbox]
         }
-      });
+      })
     }
 
     // Reading variables
     if (typeof ovc.v === 'object') {
       Object.keys(ovc.v).forEach(id => {
-        const currentVariable = ovc.v[id];
+        const currentVariable = ovc.v[id]
 
         // If it's a multiple
         if (Array.isArray(currentVariable)) {
-          inputs.variables[id] = currentVariable;
+          inputs.variables[id] = currentVariable
           // Getting parentsTree & parent id
-          const parentsTree = references.relations.variables[id].parents;
-          const parentOption =
-            inputs.options[`${parentsTree[parentsTree.length - 1]}`];
+          const parentsTree = references.relations.variables[id].parents
+          const parentOption = inputs.options[`${parentsTree[parentsTree.length - 1]}`]
           if (Array.isArray(parentOption)) {
-            const occurences = parentOption.length;
+            const occurences = parentOption.length
             if (currentVariable.length < occurences) {
-              inputs.variables[id] = [
-                ...currentVariable,
-                ...Array(occurences - currentVariable.length).fill('')
-              ];
+              inputs.variables[id] = [...currentVariable, ...Array(occurences - currentVariable.length).fill('')]
             }
           }
         } else {
-          inputs.variables[id] = [currentVariable];
+          inputs.variables[id] = [currentVariable]
         }
-      });
+      })
     }
 
-    return inputs;
+    return inputs
   }
 
   public isOvc(_obj: InputsType | OvcType): _obj is OvcType {
@@ -146,31 +116,26 @@ if (typeof ovc !== 'object') return inputs;
     return foundKeys === 2
   }
 
-    private pushStaticChildren(
-    inputOptions: InputsType['options'],
-    id: number | string,
-    occurences: number,
-    references: Types.ReferencesType
-  ) {
-    const result = { ...inputOptions };
-    const intId = typeof id === 'number' ? id : parseInt(id, 10);
+  private pushStaticChildren(inputOptions: InputsType['options'], id: number | string, occurences: number, references: Types.ReferencesType) {
+    const result = { ...inputOptions }
+    const intId = typeof id === 'number' ? id : parseInt(id, 10)
 
     // Getting children options and variables
-    const { options } = references.relations.options[intId].children;
+    const { options } = references.relations.options[intId].children
 
     // Getting static children
     const staticOptions = options.filter(childId => {
-      return references.options[childId].meta.type === 'static';
-    });
+      return references.options[childId].meta.type === 'static'
+    })
 
     staticOptions.forEach(childId => {
       // Creating input if it doesn't exist
       if (!Object.prototype.hasOwnProperty.call(result, childId)) {
-        result[childId] = new Array(occurences).fill(false);
+        result[childId] = new Array(occurences).fill(false)
       }
-    });
+    })
 
-    return result;
+    return result
   }
 }
 

package/src/types/ovc.type.ts

@@ -10,4 +10,4 @@ interface OvcType {
   }
 }
 
-export default OvcType
+export default OvcType

package/src/types/tags.type.ts

@@ -4,19 +4,21 @@ interface TagsType {
 }
 
 export interface OptionTagType {
-  id: number;
-  index: number;
-  label: string;
-  condition: boolean;
+  id: number
+  index: number
+  label: string
+  condition: boolean
+  visible: boolean
   value: boolean
 }
 
 export interface VariableTagType {
-  id: number;
-  index: number;
-  label: string;
-  condition: boolean;
+  id: number
+  index: number
+  label: string
+  condition: boolean
+  visible: boolean
   value: string | number
 }
 
-export default TagsType
+export default TagsType

package/model.ts

@@ -1,84 +0,0 @@
-import { ModelV3 } from "@legalplace/models-v3-types"
-
-export const model: ModelV3 = {
-  "documents": {
-    "main": {
-      "name": "main",
-      "sections": [{
-        "id": 1,
-        "label": "Titre de la section",
-        "options": [1, 2]
-      }, {
-        "id": 2,
-        "label": "Titre de la section",
-        "options": [3]
-      }]
-    }
-  },
-  "options": {
-    "1": {
-      "meta": {
-        "type": "hidden",
-        "label": "Text de la question",
-        "output": "<p><span style=\"font-weight:bold;\">[var:1]</span><span style=\"font-weight:bold;\">  </span>  \n  <span style=\"font-weight:bold;\">[var:2]</span><span style=\"font-weight:bold;\"></span></p><p></p><p>[var:1]  [var:2]</p><p></p><p>blablabla</p><p>blablabla</p>",
-        "step": "*",
-        "id": 1
-      },
-      "variables": [],
-      "options": []
-    },
-    "2": {
-      "meta": {
-        "type": "static",
-        "id": 2,
-        "label": "Question",
-        "step": "*"
-      },
-      "options": [],
-      "variables": [1, 2]
-    },
-    "3": {
-      "meta": {
-        "type": "checkbox",
-        "id": 3,
-        "step": "*",
-        "label": "Case à cocher",
-        "tags": ["test", "test2"]
-      },
-      "options": [],
-      "variables": []
-    }
-  },
-  "variables": {
-    "1": {
-      "type": "text",
-      "id": 1,
-      "label": "ChampA",
-      "step": "*",
-      "mandatory": false,
-      "placeholder": "",
-      "tags": ["Hello"]
-    },
-    "2": {
-      "type": "text",
-      "id": 2,
-      "label": "ChampB",
-      "step": "*",
-      "mandatory": false,
-      "placeholder": "",
-      "tags": ["Hello"]
-    }
-  },
-  "customization": {}
-}
-
-export const ovc = {
-  "o": {},
-  "v": {
-    "1": "cccc",
-    "2": "dddddd"
-  },
-  "c": {
-    "3": false
-  }
-}

package/test.ts

@@ -1,8 +0,0 @@
-import * as fs from 'fs'
-import { model, ovc} from './model'
-import TagsExtractor from './src'
-
-
-const tags = new TagsExtractor(model, ovc).getTags
-
-console.log(JSON.stringify(tags))