@legalplace/lplogic 2.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.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": ["**/*.test.ts", "**/*.spec.ts"]
+    }],
+    "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,28 @@
+image: node:11-alpine
+
+
+stages:
+  - deploy
+
+before_script:
+- export PATH=$PATH:./node_modules/.bin/
+
+variables: 
+  DOCKER_DRIVER: overlay2
+
+publish:
+  image: node:11-alpine
+  stage: deploy
+  except:
+    variables:
+      - $CI_COMMIT_MESSAGE =~ /skip-publish/
+  script:
+    - echo -e "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > ~/.npmrc
+    - yarn install
+    - yarn build
+    - npm publish
+    - echo "PUBLISHED SUCCESSFULLY"
+  environment:
+    name: development
+  only:
+  - master

package/.vscode/settings.json

@@ -0,0 +1,23 @@
+{
+  "eslint.enable": true,
+  "editor.tabSize": 2,
+  "eslint.validate": [
+    "javascript",
+    {
+      "autoFix": true,
+      "language": "typescript"
+    }
+  ],
+  "eslint.options": {
+    "extensions": [".ts", ".js"]
+  },
+  "files.autoSave": "onFocusChange",
+  "editor.formatOnSave": false,
+  "editor.formatOnType": true,
+  "prettier.singleQuote": true,
+  "eslint.packageManager": "yarn",
+  "eslint.quiet": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true 
+  }
+}

package/.vscode/tasks.json

@@ -0,0 +1,24 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558 
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "lint",
+      "problemMatcher": [
+        "$eslint-stylish",
+        "$tsc"
+      ]
+    },
+    {
+      "type": "typescript",
+      "tsconfig": "tsconfig.json",
+      "option": "watch",
+      "problemMatcher": [
+        "$tsc-watch"
+      ],
+      "group": "build"
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,149 @@
+# LpLogic
+
+LpLogic
+
+# Setup
+```
+npm install --save git+ssh://git@git.legalplace.eu:legalplace/lplogic.git
+```
+
+# Libraries
+
+
+## LpLogic
+An extension of JsonLogic supporting LegalPlace's conditions operators:
+* selected : Returns true only if the tested input is `true` or an array containing only `true` value
+* not-selected : Returns true only if the tested input is `false` or an array containing only `false` value
+* has-one : Returns true only if the tested input is an array with a length === 1
+* at-least-one : Returns true only if the tested input is an array containing at least one value as `true`
+* has-many :  Returns true only if the tested input is an array with a length > 1
+* contains : Returns true only if the input is equal to the conditon's value input or the input is an array with all its values equal to the conditon's value
+* does-not-contain :  Returns true only if the input is not equal to the conditon's value or the input is an array with all its values not equal to the conditon's value
+
+### Usage
+```javascript
+import LpLogic from "lplogic"
+
+// Returns true
+LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":true}})
+LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})
+
+// Returns false
+LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":false}})
+LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})
+
+// Returns true
+LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":false}})
+LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[false, false]}})
+
+// Returns false
+LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":true}})
+LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})
+
+// Returns true
+LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true]}})
+
+// Returns false
+LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})
+
+// Returns true
+LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})
+
+// Returns false
+LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true]}})
+
+// Returns true
+LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, true]}})
+
+// Returns false
+LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, false]}})
+
+// Returns true
+LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}})
+LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello","Hello"]}})
+
+// Returns false
+LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}})
+LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello","Bye"]}})
+
+// Returns true
+LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}})
+LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Bye","Bye"]}}) 
+
+// Returns false
+LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}})
+LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello","Bye"]}})
+
+```
+
+
+## Parser
+Parsing ConditionV1 objects to LpLogic object
+
+### Usage
+```js
+import { Parser, References } from "lplogic"
+
+let model = {
+    documents: {
+        "main": {
+            sections: [{
+                "id": 1,
+                "label": "It's 3 am",
+                "options": [1,2]
+            }]
+        }
+    },
+    options: {
+        "1": {
+            meta: {
+                id: 1,
+                type: "checkbox",
+                label: "Check me to see Option 2",
+                conditional: false
+            },
+            children:[],
+            variables: []
+        },
+        "2": {
+            meta: {
+                id: 2,
+                type: "checkbox",
+                label: "Hey ! it's option 2",
+                conditional: true,
+                compiledConditions: [{
+                    c: "selected",
+                    o: 1
+                }]
+            },
+            children:[],
+            variables: []
+        }
+
+    },
+    variables: {}
+}
+
+// Setting References before starting to parse
+let sections = model.documents.main.sections
+let options = model.options
+let variables = model.variables
+References.setRefs(sections, options, variables);
+
+// Parsing conditions on Option 2
+let conditions = new Parser( options["2"].meta.compiledConditions ).getLogic()
+```
+In this example, the variable `conditions` should be equal to
+```json
+{"selected":[{"var":"o.1"}]}
+```
+
+# MISC
+## Running tests
+```
+npm test
+```
+### Building
+```
+npm run build
+```

package/dist/LpLogic.d.ts

@@ -0,0 +1,3 @@
+import jsonLogic from "@legalplace/json-logic-js";
+declare const LpLogic: typeof jsonLogic.apply;
+export default LpLogic;

package/dist/LpLogic.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var json_logic_js_1 = __importDefault(require("@legalplace/json-logic-js"));
+json_logic_js_1.default.add_operation("=", function (value, comparator) {
+    if (!Array.isArray(value)) {
+        return value === comparator;
+    }
+    var filter = value.filter(function (_value) { return _value === comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("<>", function (value, comparator) {
+    if (!Array.isArray(value)) {
+        return value !== comparator;
+    }
+    var filter = value.filter(function (_value) { return _value !== comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("==", function (value, comparator) {
+    if (!Array.isArray(value)) {
+        return value === comparator;
+    }
+    var filter = value.filter(function (_value) { return _value === comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation(">=", function (value, c) {
+    var comparator = typeof c === "number" ? c : parseFloat(c);
+    if (!Array.isArray(value)) {
+        return value >= comparator;
+    }
+    var filter = value.filter(function (_value) { return _value >= comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("<=", function (value, c) {
+    var comparator = typeof c === "number" ? c : parseFloat(c);
+    if (!Array.isArray(value)) {
+        return value >= comparator;
+    }
+    var filter = value.filter(function (_value) { return _value <= comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation(">", function (value, c) {
+    var comparator = typeof c === "number" ? c : parseFloat(c);
+    if (!Array.isArray(value)) {
+        return value > comparator;
+    }
+    var filter = value.filter(function (_value) { return _value > comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("<", function (value, c) {
+    var comparator = typeof c === "number" ? c : parseFloat(c);
+    if (!Array.isArray(value)) {
+        return value < comparator;
+    }
+    var filter = value.filter(function (_value) { return _value < comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("selected", function (value) {
+    if (!Array.isArray(value)) {
+        return value === true;
+    }
+    var filter = value.filter(function (_value) { return _value === true; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("not-selected", function (value) {
+    if (!Array.isArray(value)) {
+        return value !== true;
+    }
+    var filter = value.filter(function (_value) { return _value !== true; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("has-one", function (value) {
+    if (!Array.isArray(value))
+        return true;
+    return value.length === 1;
+});
+json_logic_js_1.default.add_operation("at-least-one", function (value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.includes(true);
+});
+json_logic_js_1.default.add_operation("has-many", function (value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.length > 1;
+});
+json_logic_js_1.default.add_operation("contains", function (value, comparator) {
+    if (!Array.isArray(value))
+        return value === comparator;
+    var filter = value.filter(function (_value) { return _value === comparator; });
+    return value.length === filter.length;
+});
+json_logic_js_1.default.add_operation("does-not-contain", function (value, comparator) {
+    if (!Array.isArray(value))
+        return value !== comparator;
+    var filter = value.filter(function (_value) { return _value !== comparator; });
+    return value.length === filter.length;
+});
+var LpLogic = json_logic_js_1.default.apply;
+exports.default = LpLogic;

package/dist/Parser.d.ts

@@ -0,0 +1,12 @@
+import { ConditionV3 } from "@legalplace/models-v3-types";
+import { CompiledConditionV1, ConditionV1Single } from "./definitions/model-v1-schema";
+declare class Parser {
+    id: number | undefined;
+    logic: ConditionV3;
+    constructor(conditions: CompiledConditionV1, id?: number);
+    getLogic(): ConditionV3;
+    validateCondition(condition: ConditionV1Single): void;
+    convertConditions(conditions: CompiledConditionV1): ConditionV3;
+    convertSingleCondition(condition: ConditionV1Single): ConditionV3;
+}
+export default Parser;

package/dist/Parser.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var jsonschema_1 = require("jsonschema");
+var condition_v1_schema_1 = __importDefault(require("./schemas/condition-v1-schema"));
+var Parser = (function () {
+    function Parser(conditions, id) {
+        this.id = id;
+        this.logic = this.convertConditions(conditions);
+    }
+    Parser.prototype.getLogic = function () {
+        return this.logic;
+    };
+    Parser.prototype.validateCondition = function (condition) {
+        var result = jsonschema_1.validate(condition, condition_v1_schema_1.default);
+        if (result.errors.length > 0) {
+            throw new Error(JSON.stringify(condition) + " is not a valid condition");
+        }
+    };
+    Parser.prototype.convertConditions = function (conditions) {
+        var _this = this;
+        var operator;
+        if (Array.isArray(conditions) && conditions.length === 0)
+            return {};
+        for (var index = 0; index < conditions.length; index += 1) {
+            var value = conditions[index];
+            if (typeof value.t === "string" && value.t && index > 0) {
+                if (operator === undefined && typeof value.t === "string") {
+                    operator = value.t;
+                }
+                else if (value.t !== operator) {
+                    throw new Error("Conditions object is not valid, " + operator + " is not equal to " + value.t + " at index " + index + " in " + JSON.stringify(conditions));
+                }
+            }
+        }
+        var logicConditions = [];
+        conditions.forEach(function (value) {
+            var currentCondition = {};
+            if (typeof value.condition_array === "object") {
+                currentCondition = _this.convertConditions(value.condition_array);
+            }
+            else if (typeof value === "object") {
+                currentCondition = _this.convertSingleCondition(value);
+            }
+            else {
+                throw new Error("Invalid condition");
+            }
+            logicConditions.push(currentCondition);
+        });
+        var logic = {};
+        if (operator !== undefined) {
+            logic[operator] = logicConditions;
+        }
+        else if (logicConditions.length === 1) {
+            logic = logicConditions[0];
+        }
+        else {
+            throw new Error("Invalid condition " + conditions);
+        }
+        return logic;
+    };
+    Parser.prototype.convertSingleCondition = function (condition) {
+        this.validateCondition(condition);
+        if (condition.c === undefined)
+            throw new Error("Invalid condition");
+        var operation = condition.c;
+        var rule = {};
+        var dataReference;
+        if (condition.o !== false && condition.o !== undefined) {
+            dataReference = {
+                var: "o." + condition.o
+            };
+            rule[operation] = [dataReference];
+        }
+        else if (condition.v !== false && condition.v !== undefined) {
+            dataReference = {
+                var: "v." + condition.v
+            };
+            rule[operation] = [dataReference, condition.value];
+        }
+        else {
+            throw new Error("Invalid condition " + condition);
+        }
+        return rule;
+    };
+    return Parser;
+}());
+exports.default = Parser;

package/dist/definitions/model-v1-schema.d.ts

@@ -0,0 +1,152 @@
+export declare type ConditionV1Single = {
+    c?: "selected" | "not-selected" | "has-one" | "at-least-one" | "has-many" | "contains" | "does-not-contain" | "=" | ">" | "<" | "!=" | ">=" | "<=" | "<>";
+    o?: false | number | string;
+    p?: string | number;
+    v?: string | number | false;
+    value?: string | number;
+    l?: false | (string | number)[];
+    m?: boolean;
+    t?: "and" | "or";
+};
+export declare type ConditionV1Array = {
+    condition_array?: ConditionV1Compose[];
+};
+declare type ConditionV1Compose = ConditionV1Array & ConditionV1Single;
+export declare type CompiledConditionV1 = ConditionV1Compose[];
+export interface ModelV1 {
+    contract_name: string;
+    sections: SectionV1[];
+    params?: {
+        sivAttributes?: {
+            [k: string]: any;
+        };
+        hasSivAttributes?: boolean;
+        is_two_steps?: boolean;
+        proIdnType?: "PRO" | "IND" | "COND";
+        disableAutoDefault?: boolean;
+        varsExtraction?: VarExtractionV1[];
+        disableCompagnon?: boolean;
+        fullWidth?: boolean;
+        disableDownloadPopup?: boolean;
+        disableDownload?: boolean;
+        disablePreview?: boolean;
+        noAttachements?: boolean;
+        isTwoSteps?: boolean;
+    };
+    options_ids?: (number | string)[];
+    variables_id?: {
+        [k: string]: any;
+    }[];
+    pro?: {
+        meta?: {
+            conditions?: CompiledConditionV1[];
+            compiledConditions?: CompiledConditionV1[];
+        };
+    };
+    [k: string]: any;
+}
+export interface SectionV1 {
+    id: string | number;
+    label: string;
+    options: OptionV1[];
+    grantLevel: "admin" | "manager" | "user" | "guest";
+    tags: string;
+    [k: string]: any;
+}
+export interface OptionV1 {
+    meta: {
+        [k: string]: any;
+        id: string | number;
+        label: string;
+        fallbackLabel?: string;
+        optionStyle?: "" | "half" | "full";
+        unvalidMessage?: string;
+        termsheetLabel?: string;
+        hideTermsheet?: boolean;
+        boxType?: "warning" | "error" | "info" | "light";
+        boxTitle?: string;
+        boxCollapsable?: boolean;
+        boxAggregatable?: boolean;
+        type: "static" | "radio" | "checkbox" | "hidden" | "brut-text" | "repeated" | "box" | "separator";
+        multiple?: boolean;
+        output?: string;
+        outputRender?: string;
+        default?: string | number;
+        parentMultiple?: boolean;
+        step_two_only?: boolean;
+        conditions?: CompiledConditionV1[];
+        compiledConditions?: CompiledConditionV1[];
+        warning?: string;
+        helper?: string;
+        multipletext?: string;
+        parent_section?: number | string;
+        multipleIncrtText?: string;
+        content?: string;
+        repeatOption?: number | string;
+        multipleIncrt?: number | string;
+        zonetendue?: boolean;
+        mandatory?: boolean;
+    };
+    children: OptionV1[];
+    variables: VariableV1[];
+    [k: string]: any;
+}
+export interface VariableV1 {
+    id: number;
+    grantLevel?: "ADMIN" | "MANAGER" | "USER" | "GUEST";
+    label: string;
+    termsheetLabel?: string;
+    type: "text" | "date" | "list" | "textarea" | "number" | "eval" | "advancedmask" | "hour" | "email" | "mask";
+    value?: string | any[];
+    suffix?: string;
+    parentMultiple?: boolean;
+    phsize?: string | number | null;
+    warning?: string;
+    helper?: string;
+    list?: any[];
+    autocomplete?: string;
+    advancedmask?: string;
+    maskph?: string;
+    mask?: string;
+    prefillings?: PrefillingV1[];
+    placeholder?: string;
+    eval_decimal?: number | string;
+    evaluation?: string;
+    round?: 0 | 1 | 2 | "0" | "1" | "2";
+    longInput?: boolean;
+    textarea_size?: "l" | "m" | "p" | "s";
+    textarea_height?: number | string;
+    mandatory?: boolean;
+    step_two_only?: boolean;
+    conditional?: boolean;
+    compiledConditions?: CompiledConditionV1 | false;
+    inputSize?: "half" | "full";
+    validator?: CompiledConditionV1 | false;
+    unvalidMessage?: string;
+    hidden?: boolean;
+    tags?: string;
+    hideTermsheet?: boolean;
+}
+export interface PrefillingV1 {
+    text?: string;
+    conditions?: CompiledConditionV1[];
+    compiledConditions?: CompiledConditionV1[];
+}
+export interface VarExtractionV1 {
+    type?: "variable" | "option";
+    index?: number | string;
+    id?: number | string;
+    parent_id?: number | string | boolean;
+    extractions?: {
+        sendinblue?: {
+            [k: string]: any;
+        };
+        mixpanel?: {
+            [k: string]: any;
+        };
+        slack?: {
+            [k: string]: any;
+        };
+    };
+}
+export {};

package/dist/definitions/model-v1-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import LpLogic from "./LpLogic";
+import Parser from "./Parser";
+export default LpLogic;
+export { Parser };

package/dist/index.js

@@ -0,0 +1,9 @@
+"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("./LpLogic"));
+var Parser_1 = __importDefault(require("./Parser"));
+exports.Parser = Parser_1.default;
+exports.default = LpLogic_1.default;