@legalplace/lplogic 2.0.0

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

@@ -0,0 +1,543 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ModelV1Schema = {
+    definitions: {
+        section: {
+            type: "object",
+            required: ["id", "label", "options"],
+            properties: {
+                id: {
+                    description: "Section's id",
+                    type: ["string", "integer"],
+                    minimum: 1
+                },
+                label: {
+                    description: "Section's title",
+                    type: "string",
+                    examples: ["Le Bailleur", "Le Locataire"]
+                },
+                options: {
+                    description: "Section's options",
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/option"
+                    }
+                }
+            }
+        },
+        option: {
+            type: "object",
+            properties: {
+                meta: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: ["string", "integer"],
+                            description: "Option's id"
+                        },
+                        type: {
+                            type: "string",
+                            description: "Option's type \n - `static`: A static question \n - `radio`: A radio input \n - `checkbox`: A checkbox input \n - `hidden`: An option that only displays an output \n - `brut-text`: An option without output that displays HTML in the wizard \n - `repeated`: A loop linked to a multiple (can only have `hidden` options as children)",
+                            enum: [
+                                "static",
+                                "radio",
+                                "checkbox",
+                                "hidden",
+                                "brut-text",
+                                "repeated"
+                            ]
+                        },
+                        multiple: {
+                            type: "boolean",
+                            description: "Can be used on root options only, if set to true, the option must allow to have duplicates with different answers for all its children"
+                        },
+                        output: {
+                            type: "string",
+                            description: "The raw option's output. Example:\n``` \nDomicilié à [var:1], [var:2]\n[var:3]```"
+                        },
+                        outputRender: {
+                            type: "string",
+                            description: 'The html option\'s output (This property is depreceated it was used by the mvp wizard (angular)). Example:\n```html \nDomicilié à <span ng-repeat="cI in [1] track by $index"><span ng-init="vars[1] = contractCtrl.variables_wrapper[1]; " ng-include="\\\'preview/var.html\\\'"></span>,  <span ng-repeat="cI in [2] track by $index"><span ng-init="vars[2] = contractCtrl.variables_wrapper[2]; " ng-include="\\\'preview/var.html\\\'"></span>\n <span ng-repeat="cI in [3] track by $index"><span ng-init="vars[3] = contractCtrl.variables_wrapper[3]; " ng-include="\\\'preview/var.html\\\'"></span>```'
+                        },
+                        default: {
+                            type: ["string", "integer"],
+                            description: "In case of a radio/checkbox/static options, this holds the default child id that should be selected in case the user advances to the next section without selecting any of the child"
+                        },
+                        parentMultiple: {
+                            type: "boolean",
+                            description: "Set to true if the root parent is a multiple option"
+                        },
+                        step_two_only: {
+                            type: "boolean",
+                            description: "Set to true if the option should be displayed in the second step only"
+                        },
+                        conditions: {
+                            description: "Raw conditions array",
+                            type: ["array", "boolean"],
+                            items: {
+                                $ref: "#/definitions/condition"
+                            }
+                        },
+                        compiledConditions: {
+                            description: "Compiled conditions array",
+                            type: ["array", "boolean"],
+                            items: {
+                                $ref: "#/definitions/compiledCondition"
+                            }
+                        },
+                        warning: {
+                            description: "The html content of the warning block",
+                            type: "string"
+                        },
+                        helper: {
+                            description: "The html content of the helper block",
+                            type: "string"
+                        },
+                        multipletext: {
+                            description: "The label of the multiple's incrementing cta",
+                            type: "string"
+                        },
+                        parent_section: {
+                            description: "Id of the parent section",
+                            type: ["integer", "string"]
+                        },
+                        multipleIncrtText: {
+                            description: "The text that preceeds the reccurency number of the multiple",
+                            type: "string"
+                        },
+                        content: {
+                            description: "The html content of the brut-text option",
+                            type: "string"
+                        },
+                        repeatOption: {
+                            description: "In case of a `repeated` option, this defines the multiple's id that the loop should be linked to",
+                            type: ["integer", "string"]
+                        },
+                        multipleIncrt: {
+                            description: "The start of the multiples incrementation counter",
+                            type: ["integer", "string"]
+                        },
+                        zonetendue: {
+                            description: 'True to enabled the "zonetendue" extension',
+                            type: "boolean"
+                        },
+                        mandatory: {
+                            description: "Set to true to make the option mandatory",
+                            type: "boolean"
+                        }
+                    }
+                },
+                children: {
+                    description: "Child options",
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/option"
+                    }
+                },
+                variables: {
+                    description: "Child variables",
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/variable"
+                    }
+                }
+            }
+        },
+        variable: {
+            type: "object",
+            description: "Variable definition object",
+            properties: {
+                id: {
+                    description: "Variable's id (must be unique)",
+                    type: ["integer", "string"]
+                },
+                label: {
+                    description: "Variable's label",
+                    type: "string",
+                    examples: ["Nom complet", "Adresse", "Date de naissance"]
+                },
+                type: {
+                    description: "Variable's type",
+                    type: "string",
+                    enum: [
+                        "text",
+                        "date",
+                        "list",
+                        "textarea",
+                        "number",
+                        "eval",
+                        "advancedmask",
+                        "hour",
+                        "email",
+                        "mask"
+                    ]
+                },
+                value: {
+                    description: "Variable's value, or values list in case of a multiple",
+                    type: ["string", "array"]
+                },
+                parentMultiple: {
+                    description: "Set to true if the root option is a multiple",
+                    type: "boolean"
+                },
+                phsize: {
+                    type: ["string", "integer", "null"],
+                    description: "Variable's place holder length"
+                },
+                warning: {
+                    description: "The html content of the warning block",
+                    type: "string"
+                },
+                helper: {
+                    description: "The html content of the helper block",
+                    type: "string"
+                },
+                list: {
+                    description: "The list of options for the select (list type) variable",
+                    type: "array"
+                },
+                autocomplete: {
+                    description: "The input's autocomplete attribute",
+                    type: "string"
+                },
+                textarea_height: {
+                    description: "The textarea's high (lines number) (Only if textarea_size is set to `p`)",
+                    type: ["integer", "string"]
+                },
+                advancedmask: {
+                    description: "The advanced mask's formula (ex: 20 ???-???-???) (?: Char & Number, !: Number Only, @: Char Only)",
+                    type: "string"
+                },
+                maskph: {
+                    description: "Mask's placeholder",
+                    type: "string"
+                },
+                mask: {
+                    description: "Mask's formula (ex: 999-999-999)",
+                    type: "string"
+                },
+                prefillings: {
+                    description: "Preffiling's object",
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/prefilling"
+                    }
+                },
+                placeholder: {
+                    description: "Input's placeholder",
+                    type: "string"
+                },
+                eval_decimal: {
+                    description: "The number of decimals for the result of an evaluation (eval type)",
+                    type: ["integer", "string"]
+                },
+                evaluation: {
+                    description: "The evaluation formula (eval type), Example: \n ``` \n[var:1]*[var:2]/[var:3]```",
+                    type: "string"
+                },
+                round: {
+                    description: "Round evalulation result (eval type). \n - `0`: Default \n - `1`: Round Up \n - `2`: Round down",
+                    type: ["string", "integer"],
+                    enum: [0, 1, 2, "0", "1", "2"]
+                },
+                longInput: {
+                    description: "Set to true to enlarge the textarea (textarea type)",
+                    type: "boolean"
+                },
+                textarea_size: {
+                    description: "Textarea's size (textarea type)\n - l: Large (240px) \n - m: Medium (120px) \n - p: Custom size in pixels",
+                    type: "string",
+                    enum: ["l", "m", "p"]
+                },
+                mandatory: {
+                    description: "True if the variable is mandatory",
+                    type: "boolean"
+                },
+                step_two_only: {
+                    type: "boolean",
+                    description: "Set to true if the variable should be displayed in the second step only"
+                }
+            }
+        },
+        condition: {
+            type: "object",
+            properties: {
+                c: {
+                    type: "string",
+                    enum: [
+                        "selected",
+                        "not-selected",
+                        "has-one",
+                        "at-least-one",
+                        "has-many",
+                        "contains",
+                        "does-not-contain"
+                    ],
+                    description: "Condition"
+                },
+                o: {
+                    type: ["string", "boolean", "integer"],
+                    description: "Option's id, set to false if the condition is related to a variable"
+                },
+                p: {
+                    type: ["string", "integer"],
+                    description: "`Depreceated` Option's parent id"
+                },
+                v: {
+                    type: ["string", "boolean", "integer"],
+                    description: "Variable's id, set to false if the condition is related to an option"
+                },
+                value: {
+                    type: ["string", "integer"],
+                    description: "Expected value (in case the condition is on a variable)"
+                },
+                l: {
+                    type: ["array", "boolean"],
+                    description: "`Depreceated` Variable's possible values list, set to false if condition is related to an option"
+                },
+                m: {
+                    type: "boolean",
+                    description: "`Depreaceated` True if the variable/option is a multiple"
+                },
+                t: {
+                    type: "string",
+                    enum: ["and", "or"],
+                    description: "Relation's op to the previous condition"
+                }
+            },
+            anyOf: [
+                {
+                    required: ["o", "c"]
+                },
+                {
+                    required: ["v", "c", "value"]
+                }
+            ]
+        },
+        compiledCondition: {
+            type: ["object", "array"],
+            description: 'The compiledCondition is whether an object or an array, it\'s a rewriting of the conditions object where the conditions with the "and" relation are separated into arrays from the "or" relations'
+        },
+        prefilling: {
+            type: "object",
+            additionalProperties: false,
+            description: "A Prefilling, is a conditionned text placeholder/example used to fill a textarea according to different conditions",
+            properties: {
+                text: {
+                    type: "string",
+                    description: "Text used to fill the textarea if the condition is realized"
+                },
+                conditions: {
+                    type: ["array", "boolean"],
+                    description: "Conditions object",
+                    items: {
+                        $ref: "#/definitions/condition"
+                    }
+                },
+                compiledConditions: {
+                    type: ["array", "boolean"],
+                    description: "Compiled conditions object",
+                    items: {
+                        $ref: "#/definitions/compiledCondition"
+                    }
+                }
+            }
+        },
+        varExtraction: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["variable", "option"],
+                    description: "Extraction's type"
+                },
+                index: {
+                    type: ["integer", "string"],
+                    description: "Used by the editor, the variables index in the variable's array list"
+                },
+                id: {
+                    type: ["integer", "string"],
+                    description: "Variable's id"
+                },
+                parent_id: {
+                    type: ["integer", "string", "boolean"],
+                    description: "Variable's parent id"
+                },
+                extractions: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        sendinblue: {
+                            ext_name: {
+                                type: "string",
+                                description: "`Static` Used by the editor to display the extraction's label"
+                            },
+                            enabled: {
+                                type: "boolean",
+                                description: "Set to true to enable Sendinblue's extraction"
+                            },
+                            name: {
+                                type: "string",
+                                description: "Sendinblue's variable name"
+                            }
+                        },
+                        mixpanel: {
+                            ext_name: {
+                                type: "string",
+                                description: "`Static` Used by the editor to display the extraction's label"
+                            },
+                            enabled: {
+                                type: "boolean",
+                                description: "Set to true to enable Mixpanel's extraction"
+                            },
+                            name: {
+                                type: "string",
+                                description: "Mixpanel's variable name"
+                            }
+                        },
+                        slack: {
+                            ext_name: {
+                                type: "string",
+                                description: "`Static` Used by the editor to display the extraction's label"
+                            },
+                            enabled: {
+                                type: "boolean",
+                                description: "Set to true to enable Slack's extraction"
+                            },
+                            name: {
+                                type: "string",
+                                description: "Slack's variable name"
+                            },
+                            channel: {
+                                type: "string",
+                                description: "Slack's channel name"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $id: "editor.json",
+    type: "object",
+    title: "Model V1",
+    required: ["contract_name", "sections"],
+    properties: {
+        contract_name: {
+            type: "string",
+            description: "The current document's main title that will be displayed on top of the wizard.",
+            examples: ["Bail de location non meublée", "Statuts SAS"]
+        },
+        sections: {
+            type: "array",
+            description: "Document's sections list",
+            items: {
+                $ref: "#/definitions/section"
+            }
+        },
+        params: {
+            type: "object",
+            additionalProperties: false,
+            description: "Model's parameters",
+            properties: {
+                sivAttributes: {
+                    type: "object",
+                    description: "`Depreceated`"
+                },
+                hasSivAttributes: {
+                    type: "boolean",
+                    description: "`Depreceated`"
+                },
+                is_two_steps: {
+                    type: "boolean",
+                    description: "Set to true to enable support of 2 steps"
+                },
+                proIdnType: {
+                    type: "string",
+                    enum: ["PRO", "IND", "COND"]
+                },
+                disableAutoDefault: {
+                    type: "boolean",
+                    description: "Set to true to disable the auto selection of default options"
+                },
+                varsExtraction: {
+                    type: "array",
+                    description: "Variables extraction logic",
+                    items: {
+                        $ref: "#/definitions/varExtraction"
+                    }
+                },
+                disableCompagnon: {
+                    type: "boolean",
+                    description: "`Depreceated` Set to true to disable the compagnon block (the gray block on the top right of the angular wizard)"
+                },
+                fullWidth: {
+                    type: "boolean",
+                    description: "Set to true to enable wizard in full width (disable preview)"
+                },
+                disableDownloadPopup: {
+                    type: "boolean",
+                    description: "`Depreceated` Set to true to disable the download CTA on to of the preview block"
+                },
+                disableDownload: {
+                    type: "boolean",
+                    description: "`Depreceated` Set to true to disable the download CTA on to of the preview block"
+                },
+                disablePreview: {
+                    type: "boolean",
+                    description: "`Depreceated` Set to true to disable the preview"
+                },
+                noAttachements: {
+                    type: "boolean",
+                    description: "`Depreceated` Set to true to disable the static Annexe files (For Bail Immobilier)"
+                },
+                isTwoSteps: {
+                    type: "boolean",
+                    description: "Set to true to enable 2 steps feature"
+                }
+            }
+        },
+        options_ids: {
+            type: "array",
+            description: "`Depreceated` Array to track options ids, this should be replaced with a simple integer counter",
+            items: {
+                type: ["integer", "string"]
+            }
+        },
+        variables_id: {
+            type: "array",
+            description: "`Depreceated` Array to track varaibles ids, this should be replaced with a simple integer counter",
+            items: {
+                type: "object"
+            }
+        },
+        pro: {
+            type: "object",
+            additionalProperties: false,
+            description: "If `prodIndType` is set to `COND`, this stores the conditions that defined whether the client is a pro or an individual",
+            properties: {
+                meta: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        conditions: {
+                            type: ["array", "boolean"],
+                            items: {
+                                $ref: "#/definitions/condition"
+                            }
+                        },
+                        compiledConditions: {
+                            type: ["array", "boolean"],
+                            items: {
+                                $ref: "#/definitions/compiledCondition"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+exports.default = ModelV1Schema;

package/jest.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+    "roots": [
+        "./tests"
+    ],
+    "transform": {
+        "^.+\\.tsx?$": "ts-jest"
+    },
+    "globals": {
+        "ts-jest": {
+            tsConfig: "tsconfig.json"
+        }
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@legalplace/lplogic",
+  "version": "2.0.0",
+  "description": "LegalPlace LpLogic",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "npx jest",
+    "build": "npx tsc"
+  },
+  "outDir": "./dist",
+  "author": "Moncef Hammou <moncef@legalplace.fr>",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.7.2",
+    "@babel/preset-typescript": "^7.7.2",
+    "@legalplace/models-v3-types": "^3.1.0",
+    "@types/jest": "^24.0.15",
+    "@types/node": "^12.6.1",
+    "@typescript-eslint/eslint-plugin": "^2.6.1",
+    "@typescript-eslint/parser": "^2.6.1",
+    "airbnb-standard": "^1.0.0",
+    "eslint": "^6.6.0",
+    "eslint-config-airbnb-base": "^14.0.0",
+    "eslint-config-prettier": "^6.5.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-prettier": "^3.1.1",
+    "jest": "^24.8.0",
+    "prettier": "1.19.1",
+    "ts-jest": "^24.0.2",
+    "typescript": "^3.7.2"
+  },
+  "dependencies": {
+    "@legalplace/json-logic-js": "^1.2.3",
+    "jsonschema": "^1.2.4"
+  }
+}

package/tests/LpLogic.test.ts

@@ -0,0 +1,90 @@
+import LpLogic from "../lib/index"
+
+test('Testing "selected" operator on a boolean `true`', async () => {
+    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":true}})).toBe(true)
+})
+
+test('Testing "selected" operator on an array of boolean `true`', async () => {
+    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})).toBe(true)
+})
+
+
+test('Testing "selected" operator on an array of boolean `false`', async () => {
+    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":false}})).toBe(false)
+})
+
+test('Testing "selected" operator on an array containing a boolean `false`', async () => {
+    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})).toBe(false)
+})
+
+test('Testing "not-selected" operator on a boolean `false`', async () => {
+    expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":false}})).toBe(true)
+})
+
+test('Testing "not-selected" operator on an array of boolean `false`', async () => {
+    expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[false, false]}})).toBe(true)
+})
+
+// Returns false
+
+test('Testing "not-selected" operator on a boolean `true`', async () => {
+    expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":true}}) ).toBe(false)
+})
+
+test('Testing "not-selected" operator on an array containing a boolean `true`', async () => {
+    expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}}) ).toBe(false)
+})
+
+// Returns true
+test('Testing "has-one" on an array of one element', async () => {
+    expect(LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true]}})).toBe(true)
+})
+
+// Returns false
+test('Testing "has-one" on an array of two elements', async () => {
+    expect( LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(false)
+})
+
+
+// Returns true
+test('Testing "has-many" on an array of two elements', async () => {
+    expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(true)
+});
+
+
+// Returns false
+test('Testing "has-many" on an array of one element', async () => {
+    expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true]}}) ).toBe(false)
+})
+
+// Returns true
+test('Testing "at-least-one" on a array of three elements with one as true', async () => {
+    expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, true]}}) ).toBe(true)
+})
+
+// Returns false
+test('Testing "at-least-one" on an array of three elements with all elements as false', async () => {
+    expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, false]}}) ).toBe(false)
+});
+
+
+// Returns true
+test('Testing "contains" Hello on a value `Hello`', async () => {
+    expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(true)
+})
+
+
+// Returns false
+test('Testing "contains" Hello on a value `Bye`', async () => {
+    expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(false)
+})
+
+// Returns true
+test('Testing "does-not-contain" Hello on a value `Bye`', async () => {
+    expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(true)
+})
+
+// Returns false
+test('Testing "does-not-contain" Hello on a value `Hello`', async () => {
+    expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(false)
+})