@legalplace/tagextractor 1.0.0

package/.eslintrc

@@ -0,0 +1,52 @@
+{
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "es6": true,
+    "jest": true,
+    "node": true
+  },
+
+  "extends": [
+    "airbnb-base",
+    "plugin:prettier/recommended"
+  ],
+
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "./tsconfig.eslint.json"
+  },
+
+  "plugins": [
+   "prettier", "@typescript-eslint"
+  ],
+
+  "rules": {
+    "prettier/prettier": ["error"],
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": ["error", {
+      "vars": "all",
+      "args": "after-used",
+      "ignoreRestSiblings": false
+    }],
+    "import/no-extraneous-dependencies": ["error", {
+      "devDependencies": true
+    }],
+    "no-continue": 0,
+    "class-methods-use-this": 0,
+    "no-underscore-dangle": 0,
+    "import/prefer-default-export": "warn",
+    "camelcase": "error",
+    "no-undef": 0,
+    "no-dupe-class-members": "off"
+  },
+
+
+  "settings": {
+    "import/resolver": {
+      "node": {
+        "extensions": [".js", ".jsx", ".ts", ".tsx"]
+      }
+    }
+  }
+}

package/.gitlab-ci.yml

@@ -0,0 +1,43 @@
+image: 148253454541.dkr.ecr.eu-west-1.amazonaws.com/legalplace:latest
+
+
+stages:
+  - setup
+  - publish
+
+before_script:
+- export PATH=$PATH:./node_modules/.bin/
+
+variables:
+  DOCKER_DRIVER: overlay2
+
+setup:
+  stage: setup
+  artifacts:
+    paths:
+    - dist/
+  only:
+    changes:
+      - yarn.lock
+      - package.json
+      - .gitlab-ci.yml
+  script:
+    - yarn -v
+    - node -v
+    - yarn install --frozen-lockfile  --check-files --silent
+    - yarn build
+
+publish:
+  stage: publish
+  except:
+    variables:
+      - $CI_COMMIT_MESSAGE =~ /skip-publish/
+  script:
+    - npm publish
+  environment:
+    name: development
+  only:
+    refs:
+    - master
+    changes:
+    - package.json

package/.prettierrc.js

@@ -0,0 +1,10 @@
+module.exports =  {
+  printWidth: 180,
+  useTabs: false,
+  tabWidth: 2,
+  semi: false,
+  singleQuote: true,
+  trailingComma: 'none',
+  parser: 'typescript',
+  endOfLine: 'lf'
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Extractor_1 = __importDefault(require("./libs/Extractor"));
+exports.default = Extractor_1.default;

package/dist/libs/ConditionsRunner.d.ts

@@ -0,0 +1,17 @@
+import { Types } from '@legalplace/referencesparser';
+import { ConditionV3 } from '@legalplace/models-v3-types';
+import { ConditionDataMap } from './DataPopulator';
+import InputsType from '../types/inputs.type';
+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;
+    executeCondition(condition: {
+        dataMap: ConditionDataMap;
+        conditions: ConditionV3;
+    }, id: number, index: number, conditionType: 'options' | 'optionValidator' | 'variables' | 'prefillers' | 'variableValidator' | 'sections' | 'documents'): any;
+}
+export default ConditionsRunner;

package/dist/libs/ConditionsRunner.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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.isOptionRelatedToOption = function (optionA, optionB) {
+        var OptionBParents = this.references.relations.options[optionB].parents;
+        var OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        var 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;
+    };
+    ConditionsRunner.prototype.isVariableRelatedToOption = function (variableId, optionId) {
+        var variableParentId = this.references.relations.variables[variableId].parents[0];
+        var optionParents = this.references.relations.options[variableParentId].parents;
+        var optionRoot = optionParents[optionParents.length - 1];
+        var optionRootRelations = optionRoot ? this.references.relations.options[optionRoot] : undefined;
+        if (optionRootRelations) {
+            if (optionRootRelations.children.options.includes(optionId) || optionRootRelations.dependants.includes(optionId)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    ConditionsRunner.prototype.isVariableRelatedToVariable = function (variableA, variableB) {
+        var optionA = this.references.relations.variables[variableA].parents[0];
+        var optionB = this.references.relations.variables[variableB].parents[0];
+        var OptionBParents = this.references.relations.options[optionB].parents;
+        var OptionBRoot = OptionBParents[OptionBParents.length - 1];
+        var 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;
+    };
+    ConditionsRunner.prototype.executeCondition = function (condition, id, index, conditionType) {
+        var _this = this;
+        if (Array.isArray(condition))
+            return condition.map(function (_condition) { return _this.executeCondition(_condition, id, index, conditionType); });
+        var 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') {
+            var 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();
+        }
+        return lplogic_1.default(condition.conditions, currentData);
+    };
+    return ConditionsRunner;
+}());
+exports.default = ConditionsRunner;

package/dist/libs/DataPopulator.d.ts

@@ -0,0 +1,53 @@
+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 getOptionConditions;
+    private getVariablesConditions;
+    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[];
+        v: number[];
+    };
+}
+export interface ConditionData {
+    o: Record<string, boolean[]>;
+    v: Record<string, (string | number)[]>;
+    c: {
+        o: Record<string, boolean[]>;
+        s: Record<string, boolean[]>;
+        v: Record<string, boolean[]>;
+    };
+}
+export default DataPopulator;

package/dist/libs/DataPopulator.js

@@ -0,0 +1,194 @@
+"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: {},
+                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();
+    }
+    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 !== false];
+        }
+        for (var i = 0; i < this.dataMap.c.o.length; i += 1) {
+            var optionId = this.dataMap.c.o[i];
+            var optionCondition = __spreadArrays(this.getOptionConditions(optionId));
+            this.data.c.o[optionId] = optionCondition === undefined ? [false] : optionCondition;
+        }
+        for (var i = 0; i < this.dataMap.c.v.length; i += 1) {
+            var variableId = this.dataMap.c.v[i];
+            var variableCondition = __spreadArrays(this.getVariablesConditions(variableId));
+            this.data.c.v[variableId] = variableCondition === undefined ? [false] : variableCondition;
+        }
+    };
+    DataPopulator.prototype.getOptionConditions = function (optionId) {
+        var conditions = this.optionConditionValue(optionId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        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 [conditions[this.index]];
+        }
+        return conditions;
+    };
+    DataPopulator.prototype.getVariablesConditions = function (variableId) {
+        var conditions = this.variableConditionValue(variableId);
+        if (conditions === undefined)
+            return [true];
+        if (this.id === undefined || this.index === undefined) {
+            return conditions;
+        }
+        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) {
+            return [conditions[this.index]];
+        }
+        return conditions;
+    };
+    DataPopulator.prototype.populateVariables = function () {
+        var _loop_1 = function (i) {
+            var variableId = this_1.dataMap.v[i];
+            var variableReference = this_1.references.variables[variableId];
+            var values = this_1.getVariableValues(variableId);
+            var parseNumber = function (v) {
+                var result = parseFloat(v);
+                return Number.isNaN(result) ? '' : result;
+            };
+            if (variableReference.type === 'number') {
+                values = values.map(function (v) { return (typeof v === 'number' ? v : parseNumber(v)); });
+            }
+            this_1.data.v[variableId] = __spreadArrays(values);
+        };
+        var this_1 = this;
+        for (var i = 0; i < this.dataMap.v.length; i += 1) {
+            _loop_1(i);
+        }
+    };
+    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];
+        var result = inputs.map(function (input, index) {
+            return _this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables');
+        });
+        return result;
+    };
+    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/Extractor.d.ts

@@ -0,0 +1,17 @@
+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 {
+    private references;
+    private inputs;
+    private conditionsRunner;
+    private tags;
+    constructor(model: ModelV3, ovc: OvcType | InputsType);
+    get getTags(): TagsType;
+    private extractFromOptions;
+    private extractFromVariables;
+    private optionConditionValue;
+    private variableConditionValue;
+}
+export default TagsExtractor;

package/dist/libs/Extractor.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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) {
+        this.tags = {
+            options: {},
+            variables: {}
+        };
+        this.references = new referencesparser_1.ReferencesParser(model).references;
+        this.inputs = OvcConverter_1.default.isOptionsVariables(ovc) ? ovc : OvcConverter_1.default.convertToOptionsVariables(ovc, this.references);
+        this.conditionsRunner = new ConditionsRunner_1.default(this.references, this.inputs);
+        this.extractFromOptions();
+        this.extractFromVariables();
+    }
+    Object.defineProperty(TagsExtractor.prototype, "getTags", {
+        get: function () {
+            return this.tags;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TagsExtractor.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],
+                            value: _this.inputs.options[id][index]
+                        });
+                    });
+                });
+            }
+        });
+    };
+    TagsExtractor.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)
+                            _this.tags.variables[tag] = [];
+                        _this.tags.variables[tag].push({
+                            id: parseInt(id, 10),
+                            index: index,
+                            label: label,
+                            condition: conditions_2[index],
+                            value: _this.inputs.variables[id][index]
+                        });
+                    });
+                });
+            }
+        });
+    };
+    TagsExtractor.prototype.optionConditionValue = function (optionId) {
+        var _this = this;
+        var conditions = this.references.conditions.options[optionId];
+        var inputs = this.inputs.options[optionId];
+        if (conditions === undefined)
+            return inputs.map(function () { return true; });
+        return inputs.map(function (input, index) {
+            return _this.conditionsRunner.executeCondition(conditions, optionId, index, 'options');
+        });
+    };
+    TagsExtractor.prototype.variableConditionValue = function (variableId) {
+        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');
+        });
+        return result;
+    };
+    return TagsExtractor;
+}());
+exports.default = TagsExtractor;

package/dist/libs/OvcConverter.d.ts

@@ -0,0 +1,11 @@
+import { Types } from '@legalplace/referencesparser';
+import InputsType from '../types/inputs.type';
+import OvcType from '../types/ovc.type';
+declare class OvcConverter {
+    convertToOptionsVariables(ovc: OvcType, references: Types.ReferencesType): InputsType;
+    isOvc(_obj: InputsType | OvcType): _obj is OvcType;
+    isOptionsVariables(_obj: InputsType | OvcType): _obj is InputsType;
+    private pushStaticChildren;
+}
+declare const _default: OvcConverter;
+export default _default;