@arquimedes.co/eureka-forms 2.0.99 → 3.0.1-refactor

package/dist/FormSteps/StepFunctions.js

@@ -1,43 +1,32 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueDataTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
 import CBRFormStepTypes from '../constants/CBRFormStepTypes';
 import AYFFormStepTypes from '../constants/AYFFormStepTypes';
 import { getRawText } from '../Utils/DraftFunctions';
-import ConditionTypes, { ExpressionTypes, OperatorTypes, } from '../constants/ConditionTypes';
+import ConditionTypes, { ExpressionTypes, OperatorTypes } from '../constants/ConditionTypes';
 import EntityPropertyTypes from '../constants/EntityPropertyTypes';
 export function calcFillerSize(step, steps, values, size) {
-    var _a;
-    var maxSize = (_a = step.maxSize) !== null && _a !== void 0 ? _a : size.blockNum;
+    const maxSize = step.maxSize ?? size.blockNum;
     if (maxSize < size.blockNum) {
-        var tsize = recursivelyCheckOpenSize(step.id, steps, values);
-        var stepSize = maxSize - tsize;
-        return (size.blockSize * stepSize + size.spacingSize * (stepSize - 1) + 20);
+        const tsize = recursivelyCheckOpenSize(step.id, steps, values);
+        const stepSize = maxSize - tsize;
+        return size.blockSize * stepSize + size.spacingSize * (stepSize - 1) + 20;
     }
     else {
         return 0;
     }
 }
 function recursivelyCheckOpenSize(idStep, steps, values) {
-    var step = steps[idStep];
-    var value = values[idStep];
+    const step = steps[idStep];
+    const value = values[idStep];
     switch (step.type) {
         case FormStepTypes.SELECTOR: {
-            var size = step.size;
+            let size = step.size;
             if (value) {
-                var currentOption = step.options.find(function (option) { return option.value === value.value; });
-                if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === OptionTypes.NESTED) {
-                    var optionSize = 0;
-                    for (var _i = 0, _a = currentOption.steps; _i < _a.length; _i++) {
-                        var pStepId = _a[_i];
-                        var temp = recursivelyCheckOpenSize(pStepId, steps, values);
+                const currentOption = step.options.find((option) => option.value === value.value);
+                if (currentOption?.type === OptionTypes.NESTED) {
+                    let optionSize = 0;
+                    for (const pStepId of currentOption.steps) {
+                        const temp = recursivelyCheckOpenSize(pStepId, steps, values);
                         optionSize += temp;
                     }
                     size += optionSize;
@@ -46,13 +35,12 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.CLASSIFIER_SELECTOR: {
-            var size = step.size;
+            let size = step.size;
             if (value) {
-                var currentOption = step.options[value];
-                if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === ClassifierOptionTypes.NESTED) {
-                    var optionSize = 0;
-                    for (var _b = 0, _c = currentOption.steps; _b < _c.length; _b++) {
-                        var pStepId = _c[_b];
+                const currentOption = step.options[value];
+                if (currentOption?.type === ClassifierOptionTypes.NESTED) {
+                    let optionSize = 0;
+                    for (const pStepId of currentOption.steps) {
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -61,13 +49,12 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.ENTITYVALUEPICKER: {
-            var size = step.size;
+            let size = step.size;
             if (value) {
-                var currentOption = step.options[value];
-                if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === EntityValueOptionTypes.NESTED) {
-                    var optionSize = 0;
-                    for (var _d = 0, _e = currentOption.steps; _d < _e.length; _d++) {
-                        var pStepId = _e[_d];
+                const currentOption = step.options[value];
+                if (currentOption?.type === EntityValueOptionTypes.NESTED) {
+                    let optionSize = 0;
+                    for (const pStepId of currentOption.steps) {
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -76,13 +63,12 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.API_SELECTOR: {
-            var size = step.size;
+            let size = step.size;
             if (value) {
-                var currentOption = step.options[value];
-                if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === ApiSelectorOptionTypes.NESTED) {
-                    var optionSize = 0;
-                    for (var _f = 0, _g = currentOption.steps; _f < _g.length; _f++) {
-                        var pStepId = _g[_f];
+                const currentOption = step.options[value];
+                if (currentOption?.type === ApiSelectorOptionTypes.NESTED) {
+                    let optionSize = 0;
+                    for (const pStepId of currentOption.steps) {
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -91,11 +77,10 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.CHECKBOX: {
-            var size = step.size;
-            var stepSteps = value ? step.steps : step.uncheckedSteps;
-            var optionSize = 0;
-            for (var _h = 0, _j = stepSteps !== null && stepSteps !== void 0 ? stepSteps : []; _h < _j.length; _h++) {
-                var pStepId = _j[_h];
+            let size = step.size;
+            const stepSteps = value ? step.steps : step.uncheckedSteps;
+            let optionSize = 0;
+            for (const pStepId of stepSteps ?? []) {
                 optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
             }
             size += optionSize;
@@ -109,21 +94,20 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return 4;
     }
 }
-export var calcStepWidth = function (stepSize, size) {
+export const calcStepWidth = (stepSize, size) => {
     return size.blockSize * stepSize + size.spacingSize * (stepSize - 1);
 };
-export var calcDefaultValue = function (step) {
-    var _a, _b;
+export const calcDefaultValue = (step) => {
     switch (step.type) {
         case FormStepTypes.CHECKBOX:
-            return (_a = step.defaultValue) !== null && _a !== void 0 ? _a : false;
+            return step.defaultValue ?? false;
         case FormStepTypes.TITLE:
             return undefined;
         case FormStepTypes.TIMEPICKER:
             return step.defaultValue;
         case FormStepTypes.SELECTOR:
             if (step.defaultValue)
-                return ((_b = step.options.find(function (option) { return option.value === step.defaultValue; })) !== null && _b !== void 0 ? _b : '');
+                return step.options.find((option) => option.value === step.defaultValue) ?? '';
             return '';
         case FormStepTypes.TEXTINPUT:
         case FormStepTypes.CLASSIFIER_SELECTOR:
@@ -150,22 +134,20 @@ export var calcDefaultValue = function (step) {
             return undefined;
     }
 };
-export var iterateNestedSteps = function (idStep, steps, iteration) {
-    var step = steps[idStep];
+export const iterateNestedSteps = (idStep, steps, iteration) => {
+    const step = steps[idStep];
     if (!step) {
         console.error('Missing Step:', idStep);
         return;
     }
     iteration(step);
     if (step.type === FormStepTypes.MAPPER) {
-        for (var _i = 0, _a = step.rootSteps; _i < _a.length; _i++) {
-            var idStep_1 = _a[_i];
-            iterateNestedSteps(idStep_1, step.steps, iteration);
+        for (const idStep of step.rootSteps) {
+            iterateNestedSteps(idStep, step.steps, iteration);
         }
     }
     else {
-        for (var _b = 0, _c = calcSubSteps(step.id, steps); _b < _c.length; _b++) {
-            var idSubStep = _c[_b];
+        for (const idSubStep of calcSubSteps(step.id, steps)) {
             iterateNestedSteps(idSubStep, steps, iteration);
         }
     }
@@ -176,24 +158,22 @@ export var iterateNestedSteps = function (idStep, steps, iteration) {
  * @param idModifier optional modifier for the ids of the substeps and all other properties
  * @returns list of the ids of the substeps of the step, if modifier returns modified steps
  */
-export var calcSubSteps = function (idStep, allSteps, idModifier) {
-    var _a;
-    var step = allSteps[idStep];
-    var subSteps = [];
+export const calcSubSteps = (idStep, allSteps, idModifier) => {
+    const step = allSteps[idStep];
+    const subSteps = [];
     if (!step)
         return [];
-    var handleSteps = function (steps) {
-        for (var i = 0; i < steps.length; i++) {
-            var idSubStep = steps[i];
+    const handleSteps = (steps) => {
+        for (let i = 0; i < steps.length; i++) {
+            const idSubStep = steps[i];
             if (idModifier)
                 steps[i] = idModifier(steps[i]);
-            subSteps.push.apply(subSteps, __spreadArray([idSubStep], calcSubSteps(idSubStep, allSteps, idModifier), false));
+            subSteps.push(idSubStep, ...calcSubSteps(idSubStep, allSteps, idModifier));
         }
     };
     switch (step.type) {
         case FormStepTypes.SELECTOR: {
-            for (var _i = 0, _b = step.options; _i < _b.length; _i++) {
-                var option = _b[_i];
+            for (const option of step.options) {
                 if (option.type === OptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -201,9 +181,8 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
             break;
         }
         case FormStepTypes.CLASSIFIER_SELECTOR:
-            for (var _c = 0, _d = Object.keys(step.options); _c < _d.length; _c++) {
-                var idOption = _d[_c];
-                var option = step.options[idOption];
+            for (const idOption of Object.keys(step.options)) {
+                const option = step.options[idOption];
                 if (option.type === ClassifierOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -211,8 +190,7 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
             break;
         case FormStepTypes.RATING:
             if (step.nestedSteps) {
-                for (var _e = 0, _f = step.nestedSteps; _e < _f.length; _e++) {
-                    var steps = _f[_e];
+                for (const steps of step.nestedSteps) {
                     handleSteps(steps);
                 }
             }
@@ -230,22 +208,19 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
         }
         case FormStepTypes.ENTITYVALUEPICKER:
             if (idModifier) {
-                for (var _g = 0, _h = step.path; _g < _h.length; _g++) {
-                    var path = _h[_g];
+                for (const path of step.path) {
                     if (path.type === EntityValueDataTypes.STEP) {
                         path.idStep = idModifier(path.idStep);
                     }
                 }
-                for (var _j = 0, _k = step.filters; _j < _k.length; _j++) {
-                    var filter = _k[_j];
+                for (const filter of step.filters) {
                     if (filter.type === EntityValueDataTypes.STEP) {
                         filter.idStep = idModifier(filter.idStep);
                     }
                 }
             }
-            for (var _l = 0, _m = Object.keys((_a = step.options) !== null && _a !== void 0 ? _a : {}); _l < _m.length; _l++) {
-                var idOption = _m[_l];
-                var option = step.options[idOption];
+            for (const idOption of Object.keys(step.options ?? {})) {
+                const option = step.options[idOption];
                 if (option.type === EntityValueOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -253,7 +228,7 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
             break;
         case CBRFormStepTypes.CBR_LOCATIVAS:
             {
-                var elementStep = step;
+                const elementStep = step;
                 if (elementStep.subStep) {
                     if (idModifier)
                         elementStep.subStep = idModifier(elementStep.subStep);
@@ -262,7 +237,7 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
             }
             break;
         case AYFFormStepTypes.AYF_ICA_CITY: {
-            var cityStep = step;
+            const cityStep = step;
             if (cityStep.idNitStep) {
                 if (idModifier)
                     cityStep.idNitStep = idModifier(cityStep.idNitStep);
@@ -275,21 +250,18 @@ export var calcSubSteps = function (idStep, allSteps, idModifier) {
     }
     return subSteps;
 };
-export var evaluateCondition = function (condition, dependencies, entityValue) {
-    var _a, _b, _c;
+export const evaluateCondition = (condition, dependencies, entityValue) => {
     switch (condition.type) {
         case ConditionTypes.EXPRESSION: {
             if (condition.expression === ExpressionTypes.OR) {
-                for (var _i = 0, _d = condition.conditions; _i < _d.length; _i++) {
-                    var subCondition = _d[_i];
+                for (const subCondition of condition.conditions) {
                     if (evaluateCondition(subCondition, dependencies))
                         return true;
                 }
                 return false;
             }
             else {
-                for (var _e = 0, _f = condition.conditions; _e < _f.length; _e++) {
-                    var subCondition = _f[_e];
+                for (const subCondition of condition.conditions) {
                     if (!evaluateCondition(subCondition, dependencies))
                         return false;
                 }
@@ -298,14 +270,14 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
         }
         case ConditionTypes.FORM_STEP: {
             if (isFormStepExistance(condition)) {
-                var boolFactor = condition.operator === OperatorTypes.EXISTS;
-                var value_1 = dependencies[condition.idStep].value;
-                if (value_1)
+                const boolFactor = condition.operator === OperatorTypes.EXISTS;
+                const value = dependencies[condition.idStep].value;
+                if (value)
                     return boolFactor;
                 return !boolFactor;
             }
-            var dependency = dependencies[condition.idStep];
-            var value_2 = dependencies[condition.idStep].value;
+            const dependency = dependencies[condition.idStep];
+            const value = dependencies[condition.idStep].value;
             switch (condition.stepType) {
                 // case FormStepTypes.AGENTPICKER:
                 //     return await evaluateAgentCondition(
@@ -313,25 +285,24 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
                 //         value as string[]
                 //     );
                 case FormStepTypes.CHECKBOX: {
-                    var boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    return value_2 === condition.value ? boolFactor : !boolFactor;
+                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
+                    return value === condition.value ? boolFactor : !boolFactor;
                 }
                 case FormStepTypes.TIMEPICKER: {
-                    var boolFactor = condition.operator === OperatorTypes.INCLUDES;
-                    if (!value_2)
+                    const boolFactor = condition.operator === OperatorTypes.INCLUDES;
+                    if (!value)
                         return !boolFactor;
-                    var evaluateCondition_1 = function (condition) {
-                        var property = condition.property;
+                    const evaluateCondition = (condition) => {
+                        const property = condition.property;
                         if (property === 'working') {
-                            var boolFactor_1 = condition.propertyOperator ===
-                                OperatorTypes.EQUAL;
-                            if (value_2.working === condition.value) {
-                                return boolFactor_1;
+                            const boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
+                            if (value.working === condition.value) {
+                                return boolFactor;
                             }
-                            return !boolFactor_1;
+                            return !boolFactor;
                         }
                         else {
-                            var time = value_2;
+                            const time = value;
                             switch (condition.propertyOperator) {
                                 case OperatorTypes.EQUAL: {
                                     return time[property] === condition.value;
@@ -340,13 +311,13 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
                                     return time[property] !== condition.value;
                                 }
                                 case OperatorTypes.LESS: {
-                                    var propValue = time[property];
+                                    const propValue = time[property];
                                     if (!propValue)
                                         return false;
                                     return propValue < condition.value;
                                 }
                                 case OperatorTypes.MORE: {
-                                    var propValue = time[property];
+                                    const propValue = time[property];
                                     if (!propValue)
                                         return false;
                                     return propValue > condition.value;
@@ -357,34 +328,28 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
                             }
                         }
                     };
-                    return evaluateCondition_1(condition)
-                        ? boolFactor
-                        : !boolFactor;
+                    return evaluateCondition(condition) ? boolFactor : !boolFactor;
                 }
                 case FormStepTypes.DATEPICKER: {
-                    if (!(value_2 instanceof Date) || isNaN(value_2.getTime())) {
+                    if (!(value instanceof Date) || isNaN(value.getTime())) {
                         return condition.operator === OperatorTypes.NOTEQUAL;
                     }
-                    var propertyDate = new Date(condition.value);
+                    const propertyDate = new Date(condition.value);
                     switch (condition.operator) {
                         case OperatorTypes.EQUAL:
-                            return (value_2.toUTCString().split('T')[0] ===
-                                propertyDate.toUTCString().split('T')[0]);
+                            return value.toUTCString().split('T')[0] === propertyDate.toUTCString().split('T')[0];
                         case OperatorTypes.NOTEQUAL:
-                            return (value_2.toUTCString().split('T')[0] !==
-                                propertyDate.toUTCString().split('T')[0]);
+                            return value.toUTCString().split('T')[0] !== propertyDate.toUTCString().split('T')[0];
                         case OperatorTypes.LESS:
-                            return value_2.getTime() < propertyDate.getTime();
+                            return value.getTime() < propertyDate.getTime();
                         case OperatorTypes.MORE:
-                            return value_2.getTime() > propertyDate.getTime();
+                            return value.getTime() > propertyDate.getTime();
                         default:
                             return false;
                     }
                 }
                 case FormStepTypes.SELECTOR: {
-                    var val = dependency.type === 'ORIGINAL'
-                        ? value_2
-                        : (_a = value_2 === null || value_2 === void 0 ? void 0 : value_2.value) !== null && _a !== void 0 ? _a : null;
+                    const val = dependency.type === 'ORIGINAL' ? value : (value?.value ?? null);
                     if (condition.operator === OperatorTypes.EQUAL) {
                         return condition.value === val;
                     }
@@ -394,61 +359,58 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
                 }
                 case FormStepTypes.TEXTINPUT: {
                     if (condition.operator === OperatorTypes.INCLUDES) {
-                        return (_b = value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes(condition.value.toLowerCase());
+                        return value?.toLowerCase()?.includes(condition.value.toLowerCase());
                     }
                     else if (condition.operator === OperatorTypes.NOTINCLUDES) {
-                        return !((_c = value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()) === null || _c === void 0 ? void 0 : _c.includes(condition.value.toLowerCase()));
+                        return !value?.toLowerCase()?.includes(condition.value.toLowerCase());
                     }
                     else if (condition.operator === OperatorTypes.EQUAL) {
-                        return (condition.value.toLowerCase() ===
-                            (value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()));
+                        return condition.value.toLowerCase() === value?.toLowerCase();
                     }
                     else if (condition.operator === OperatorTypes.NOTEQUAL) {
-                        return !(condition.value.toLowerCase() ===
-                            (value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()));
+                        return !(condition.value.toLowerCase() === value?.toLowerCase());
                     }
                     else {
                         return false;
                     }
                 }
                 case FormStepTypes.TEXTAREA: {
-                    var words = condition.values;
-                    var regx = "\\b(".concat(words[0].toLowerCase());
-                    for (var i = 1; i < words.length; i++) {
-                        regx += "|".concat(words[i].toLowerCase());
+                    const words = condition.values;
+                    let regx = `\\b(${words[0].toLowerCase()}`;
+                    for (let i = 1; i < words.length; i++) {
+                        regx += `|${words[i].toLowerCase()}`;
                     }
                     regx += ')\\b';
                     if (condition.operator === OperatorTypes.INCLUDES) {
-                        return (value_2 && new RegExp(regx).test(value_2.toLowerCase()));
+                        return value && new RegExp(regx).test(value.toLowerCase());
                     }
                     else {
-                        return (!value_2 ||
-                            !new RegExp(regx).test(value_2.toLowerCase()));
+                        return !value || !new RegExp(regx).test(value.toLowerCase());
                     }
                 }
                 case FormStepTypes.RATING: {
-                    if (!value_2 || isNaN(value_2)) {
+                    if (!value || isNaN(value)) {
                         return condition.operator === OperatorTypes.NOTEQUAL;
                     }
                     switch (condition.operator) {
                         case OperatorTypes.EQUAL:
                         case OperatorTypes.NOTEQUAL: {
-                            var boolFactor = condition.operator === OperatorTypes.EQUAL;
-                            if (value_2 === condition.value)
+                            const boolFactor = condition.operator === OperatorTypes.EQUAL;
+                            if (value === condition.value)
                                 return boolFactor;
                             return !boolFactor;
                         }
                         case OperatorTypes.LESS:
-                            return value_2 < condition.value;
+                            return value < condition.value;
                         case OperatorTypes.MORE:
-                            return value_2 > condition.value;
+                            return value > condition.value;
                         default:
                             return false;
                     }
                 }
                 case FormStepTypes.CLASSIFIER_SELECTOR: {
-                    var boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    if ((value_2 === null || value_2 === void 0 ? void 0 : value_2.value) === condition.idValue) {
+                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
+                    if (value?.value === condition.idValue) {
                         //Si op es EQUALS (boolfactor true) evaluará a true
                         //Si op es NOTEQUALS (boolfactor false) evaluará a false
                         return boolFactor;
@@ -458,10 +420,9 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
                     return !boolFactor;
                 }
                 case FormStepTypes.ENTITYVALUEPICKER: {
-                    var boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    for (var _g = 0, _h = condition.values; _g < _h.length; _g++) {
-                        var idEntityValue = _h[_g];
-                        if ((value_2 === null || value_2 === void 0 ? void 0 : value_2._id) === idEntityValue) {
+                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
+                    for (const idEntityValue of condition.values) {
+                        if (value?._id === idEntityValue) {
                             return boolFactor;
                         }
                     }
@@ -473,7 +434,7 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
             break;
         }
         case ConditionTypes.ENTITYVALUE: {
-            if (!entityValue || !entityValue.entity)
+            if (!entityValue?.entity)
                 return false;
             return evaluateEntityValueCondition(condition, entityValue.entity, entityValue.entityValue);
         }
@@ -483,16 +444,14 @@ export var evaluateCondition = function (condition, dependencies, entityValue) {
     return false;
 };
 function isFormStepExistance(condition) {
-    return (condition.operator === OperatorTypes.EXISTS ||
-        condition.operator === OperatorTypes.NOTEXISTS);
+    return condition.operator === OperatorTypes.EXISTS || condition.operator === OperatorTypes.NOTEXISTS;
 }
-var evaluateEntityValueCondition = function (condition, entity, entityValue) {
+const evaluateEntityValueCondition = (condition, entity, entityValue) => {
     switch (condition.operator) {
         case OperatorTypes.EQUAL:
         case OperatorTypes.NOTEQUAL: {
-            var boolFactor = condition.operator === OperatorTypes.EQUAL;
-            for (var _i = 0, _a = condition.values; _i < _a.length; _i++) {
-                var value = _a[_i];
+            const boolFactor = condition.operator === OperatorTypes.EQUAL;
+            for (const value of condition.values) {
                 if (value === entityValue._id) {
                     return boolFactor;
                 }
@@ -510,86 +469,80 @@ var evaluateEntityValueCondition = function (condition, entity, entityValue) {
     }
     return false;
 };
-var evaluateEntityPropertyCondition = function (condition, entity, entityValue) {
+const evaluateEntityPropertyCondition = (condition, entity, entityValue) => {
     if (isEntityPropertyExistance(condition)) {
-        var boolFactor = condition.propertyOperator === OperatorTypes.EXISTS;
-        var value_3 = entityValue[condition.idProperty];
-        if (value_3 !== undefined) {
+        const boolFactor = condition.propertyOperator === OperatorTypes.EXISTS;
+        const value = entityValue[condition.idProperty];
+        if (value !== undefined) {
             return boolFactor;
         }
         return !boolFactor;
     }
-    var property = entity.steps[condition.idProperty];
+    const property = entity.steps[condition.idProperty];
     if (!property || property.type !== condition.propertyType) {
         return false;
     }
-    var value = entityValue[condition.idProperty];
+    const value = entityValue[condition.idProperty];
     if (value === undefined)
         return false;
     switch (condition.propertyType) {
         case EntityPropertyTypes.CHECKBOX: {
-            var boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
+            const boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
             if (value === condition.propertyValue) {
                 return boolFactor;
             }
             return !boolFactor;
         }
         case EntityPropertyTypes.DATEPICKER: {
-            var date = new Date(value);
+            const date = new Date(value);
             if (!(date instanceof Date) || isNaN(date.getTime())) {
                 return condition.propertyOperator === OperatorTypes.NOTEQUAL;
             }
             switch (condition.propertyOperator) {
                 case OperatorTypes.EQUAL: {
-                    var propertyDate = new Date(condition.propertyValue);
+                    const propertyDate = new Date(condition.propertyValue);
                     return date.getTime() === propertyDate.getTime();
                 }
                 case OperatorTypes.NOTEQUAL: {
-                    var propertyDate = new Date(condition.propertyValue);
+                    const propertyDate = new Date(condition.propertyValue);
                     return date.getTime() !== propertyDate.getTime();
                 }
                 case OperatorTypes.LESS: {
-                    var propertyDate = new Date(condition.propertyValue);
+                    const propertyDate = new Date(condition.propertyValue);
                     return date.getTime() < propertyDate.getTime();
                 }
                 case OperatorTypes.MORE: {
-                    var propertyDate = new Date(condition.propertyValue);
+                    const propertyDate = new Date(condition.propertyValue);
                     return date.getTime() > propertyDate.getTime();
                 }
                 case OperatorTypes.PAST_RELATIVE_LESS:
                 case OperatorTypes.PAST_RELATIVE_MORE:
                 case OperatorTypes.FUTURE_RELATIVE_LESS:
                 case OperatorTypes.FUTURE_RELATIVE_MORE: {
-                    var date_1 = getRelativeDate(condition.days, condition.hours, condition.minutes, condition.propertyOperator ===
-                        OperatorTypes.PAST_RELATIVE_LESS ||
-                        condition.propertyOperator ===
-                            OperatorTypes.PAST_RELATIVE_MORE);
-                    if (condition.propertyOperator ===
-                        OperatorTypes.PAST_RELATIVE_LESS ||
-                        condition.propertyOperator ===
-                            OperatorTypes.FUTURE_RELATIVE_LESS)
-                        return new Date().getTime() > date_1.getTime();
+                    const date = getRelativeDate(condition.days, condition.hours, condition.minutes, condition.propertyOperator === OperatorTypes.PAST_RELATIVE_LESS ||
+                        condition.propertyOperator === OperatorTypes.PAST_RELATIVE_MORE);
+                    if (condition.propertyOperator === OperatorTypes.PAST_RELATIVE_LESS ||
+                        condition.propertyOperator === OperatorTypes.FUTURE_RELATIVE_LESS)
+                        return new Date().getTime() > date.getTime();
                     else
-                        return new Date().getTime() < date_1.getTime();
+                        return new Date().getTime() < date.getTime();
                 }
-                default:
-                    false;
             }
             return false;
         }
         case EntityPropertyTypes.TIMEPICKER: {
-            var boolFactor = condition.propertyOperator === OperatorTypes.INCLUDES;
-            var evaluateCondition_2 = function (condition) {
-                var timeProperty = condition.property;
+            const boolFactor = condition.propertyOperator === OperatorTypes.INCLUDES;
+            const evaluateCondition = (condition) => {
+                const timeProperty = condition.property;
                 if (timeProperty === 'working') {
-                    var boolFactor_2 = condition.timePropertyOperator === OperatorTypes.EQUAL;
+                    const boolFactor = condition.timePropertyOperator === OperatorTypes.EQUAL;
                     if (value.working === condition.value) {
-                        return boolFactor_2;
+                        return boolFactor;
                     }
-                    return !boolFactor_2;
+                    return !boolFactor;
                 }
                 else {
-                    var time = value;
+                    const time = value;
                     switch (condition.timePropertyOperator) {
                         case OperatorTypes.EQUAL: {
                             return time[timeProperty] === condition.value;
@@ -598,13 +551,13 @@ var evaluateEntityPropertyCondition = function (condition, entity, entityValue)
                             return time[timeProperty] !== condition.value;
                         }
                         case OperatorTypes.LESS: {
-                            var propValue = time[timeProperty];
+                            const propValue = time[timeProperty];
                             if (!propValue)
                                 return false;
                             return propValue < condition.value;
                         }
                         case OperatorTypes.MORE: {
-                            var propValue = time[timeProperty];
+                            const propValue = time[timeProperty];
                             if (!propValue)
                                 return false;
                             return propValue > condition.value;
@@ -615,17 +568,17 @@ var evaluateEntityPropertyCondition = function (condition, entity, entityValue)
                     }
                 }
             };
-            return evaluateCondition_2(condition) ? boolFactor : !boolFactor;
+            return evaluateCondition(condition) ? boolFactor : !boolFactor;
         }
         case EntityPropertyTypes.SELECTOR:
         case EntityPropertyTypes.TEXTAREA:
         case EntityPropertyTypes.TEXTINPUT: {
             if (condition.propertyOperator === OperatorTypes.INCLUDES ||
                 condition.propertyOperator === OperatorTypes.NOTINCLUDES) {
-                var words = condition.propertyValues;
-                var regx = "\\b(".concat(words[0].toLowerCase());
-                for (var i = 1; i < words.length; i++) {
-                    regx += "|".concat(words[i].toLowerCase());
+                const words = condition.propertyValues;
+                let regx = `\\b(${words[0].toLowerCase()}`;
+                for (let i = 1; i < words.length; i++) {
+                    regx += `|${words[i].toLowerCase()}`;
                 }
                 regx += ')\\b';
                 if (condition.propertyOperator === OperatorTypes.INCLUDES) {
@@ -637,12 +590,10 @@ var evaluateEntityPropertyCondition = function (condition, entity, entityValue)
                 /** For Inputs and Selectors */
             }
             else if (condition.propertyOperator === OperatorTypes.EQUAL) {
-                return (condition.propertyValue.toLowerCase() ===
-                    value.toLowerCase());
+                return condition.propertyValue.toLowerCase() === value.toLowerCase();
             }
             else if (condition.propertyOperator === OperatorTypes.NOTEQUAL) {
-                return !(condition.propertyValue.toLowerCase() ===
-                    value.toLowerCase());
+                return !(condition.propertyValue.toLowerCase() === value.toLowerCase());
             }
             return false;
         }
@@ -652,15 +603,9 @@ var evaluateEntityPropertyCondition = function (condition, entity, entityValue)
     return false;
 };
 function isEntityPropertyExistance(condition) {
-    return (condition.propertyOperator === OperatorTypes.EXISTS ||
-        condition.propertyOperator === OperatorTypes.NOTEXISTS);
+    return (condition.propertyOperator === OperatorTypes.EXISTS || condition.propertyOperator === OperatorTypes.NOTEXISTS);
 }
-export function getRelativeDate(nDays, nHours, nMinutes, subtract, date) {
-    if (nDays === void 0) { nDays = 0; }
-    if (nHours === void 0) { nHours = 0; }
-    if (nMinutes === void 0) { nMinutes = 0; }
-    if (subtract === void 0) { subtract = false; }
-    if (date === void 0) { date = new Date(); }
-    var millis = nDays * 86400000 + nHours * 3600000 + nMinutes * 60000;
+export function getRelativeDate(nDays = 0, nHours = 0, nMinutes = 0, subtract = false, date = new Date()) {
+    const millis = nDays * 86400000 + nHours * 3600000 + nMinutes * 60000;
     return new Date(date.getTime() + (subtract ? -millis : millis));
 }