@arquimedes.co/eureka-forms 3.0.33-test → 3.0.33

package/dist/FormSteps/StepFunctions.js

@@ -1,32 +1,43 @@
+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) {
-    const maxSize = step.maxSize ?? size.blockNum;
+    var _a;
+    var maxSize = (_a = step.maxSize) !== null && _a !== void 0 ? _a : size.blockNum;
     if (maxSize < size.blockNum) {
-        const tsize = recursivelyCheckOpenSize(step.id, steps, values);
-        const stepSize = maxSize - tsize;
-        return size.blockSize * stepSize + size.spacingSize * (stepSize - 1) + 20;
+        var tsize = recursivelyCheckOpenSize(step.id, steps, values);
+        var stepSize = maxSize - tsize;
+        return (size.blockSize * stepSize + size.spacingSize * (stepSize - 1) + 20);
     }
     else {
         return 0;
     }
 }
 function recursivelyCheckOpenSize(idStep, steps, values) {
-    const step = steps[idStep];
-    const value = values[idStep];
+    var step = steps[idStep];
+    var value = values[idStep];
     switch (step.type) {
         case FormStepTypes.SELECTOR: {
-            let size = step.size;
+            var size = step.size;
             if (value) {
-                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);
+                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);
                         optionSize += temp;
                     }
                     size += optionSize;
@@ -35,12 +46,13 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.CLASSIFIER_SELECTOR: {
-            let size = step.size;
+            var size = step.size;
             if (value) {
-                const currentOption = step.options[value];
-                if (currentOption?.type === ClassifierOptionTypes.NESTED) {
-                    let optionSize = 0;
-                    for (const pStepId of currentOption.steps) {
+                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];
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -49,12 +61,13 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.ENTITYVALUEPICKER: {
-            let size = step.size;
+            var size = step.size;
             if (value) {
-                const currentOption = step.options[value];
-                if (currentOption?.type === EntityValueOptionTypes.NESTED) {
-                    let optionSize = 0;
-                    for (const pStepId of currentOption.steps) {
+                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];
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -63,12 +76,13 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.API_SELECTOR: {
-            let size = step.size;
+            var size = step.size;
             if (value) {
-                const currentOption = step.options[value];
-                if (currentOption?.type === ApiSelectorOptionTypes.NESTED) {
-                    let optionSize = 0;
-                    for (const pStepId of currentOption.steps) {
+                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];
                         optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
                     }
                     size += optionSize;
@@ -77,10 +91,11 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.CHECKBOX: {
-            let size = step.size;
-            const stepSteps = value ? step.steps : step.uncheckedSteps;
-            let optionSize = 0;
-            for (const pStepId of stepSteps ?? []) {
+            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];
                 optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
             }
             size += optionSize;
@@ -94,20 +109,21 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return 4;
     }
 }
-export const calcStepWidth = (stepSize, size) => {
+export var calcStepWidth = function (stepSize, size) {
     return size.blockSize * stepSize + size.spacingSize * (stepSize - 1);
 };
-export const calcDefaultValue = (step) => {
+export var calcDefaultValue = function (step) {
+    var _a, _b;
     switch (step.type) {
         case FormStepTypes.CHECKBOX:
-            return step.defaultValue ?? false;
+            return (_a = step.defaultValue) !== null && _a !== void 0 ? _a : false;
         case FormStepTypes.TITLE:
             return undefined;
         case FormStepTypes.TIMEPICKER:
             return step.defaultValue;
         case FormStepTypes.SELECTOR:
             if (step.defaultValue)
-                return step.options.find((option) => option.value === step.defaultValue) ?? '';
+                return ((_b = step.options.find(function (option) { return option.value === step.defaultValue; })) !== null && _b !== void 0 ? _b : '');
             return '';
         case FormStepTypes.TEXTINPUT:
         case FormStepTypes.CLASSIFIER_SELECTOR:
@@ -119,7 +135,6 @@ export const calcDefaultValue = (step) => {
                 return '';
         case FormStepTypes.RATING:
         case FormStepTypes.DATEPICKER:
-        case FormStepTypes.DATEPICKER_RANGE:
         case FormStepTypes.API_SELECTOR:
         case FormStepTypes.ENTITYVALUEPICKER:
             return null;
@@ -135,24 +150,26 @@ export const calcDefaultValue = (step) => {
             return undefined;
     }
 };
-export const iterateNestedSteps = (idStep, steps, iteration, path = [idStep]) => {
-    const step = steps[idStep];
+export var iterateNestedSteps = function (idStep, steps, iteration, path) {
+    if (path === void 0) { path = []; }
+    var step = steps[idStep];
     if (!step) {
         console.error('Missing Step:', idStep);
         return;
     }
     iteration(step, path);
     if (step.type === FormStepTypes.MAPPER) {
-        for (const idStep of step.rootSteps) {
-            iterateNestedSteps(idStep, step.steps, iteration, [
-                ...path,
+        for (var _i = 0, _a = step.rootSteps; _i < _a.length; _i++) {
+            var idStep_1 = _a[_i];
+            iterateNestedSteps(idStep_1, step.steps, iteration, __spreadArray(__spreadArray([], path, true), [
                 step.id,
-            ]);
+            ], false));
         }
     }
     else {
-        for (const idSubStep of calcSubSteps(step.id, steps)) {
-            iterateNestedSteps(idSubStep, steps, iteration, [...path, step.id]);
+        for (var _b = 0, _c = calcSubSteps(step.id, steps); _b < _c.length; _b++) {
+            var idSubStep = _c[_b];
+            iterateNestedSteps(idSubStep, steps, iteration, path);
         }
     }
 };
@@ -162,22 +179,24 @@ export const iterateNestedSteps = (idStep, steps, iteration, path = [idStep]) =>
  * @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 const calcSubSteps = (idStep, allSteps, idModifier) => {
-    const step = allSteps[idStep];
-    const subSteps = [];
+export var calcSubSteps = function (idStep, allSteps, idModifier) {
+    var _a;
+    var step = allSteps[idStep];
+    var subSteps = [];
     if (!step)
         return [];
-    const handleSteps = (steps) => {
-        for (let i = 0; i < steps.length; i++) {
-            const idSubStep = steps[i];
+    var handleSteps = function (steps) {
+        for (var i = 0; i < steps.length; i++) {
+            var idSubStep = steps[i];
             if (idModifier)
                 steps[i] = idModifier(steps[i]);
-            subSteps.push(idSubStep, ...calcSubSteps(idSubStep, allSteps, idModifier));
+            subSteps.push.apply(subSteps, __spreadArray([idSubStep], calcSubSteps(idSubStep, allSteps, idModifier), false));
         }
     };
     switch (step.type) {
         case FormStepTypes.SELECTOR: {
-            for (const option of step.options) {
+            for (var _i = 0, _b = step.options; _i < _b.length; _i++) {
+                var option = _b[_i];
                 if (option.type === OptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -185,8 +204,9 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         }
         case FormStepTypes.CLASSIFIER_SELECTOR:
-            for (const idOption of Object.keys(step.options)) {
-                const option = step.options[idOption];
+            for (var _c = 0, _d = Object.keys(step.options); _c < _d.length; _c++) {
+                var idOption = _d[_c];
+                var option = step.options[idOption];
                 if (option.type === ClassifierOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -194,7 +214,8 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         case FormStepTypes.RATING:
             if (step.nestedSteps) {
-                for (const steps of step.nestedSteps) {
+                for (var _e = 0, _f = step.nestedSteps; _e < _f.length; _e++) {
+                    var steps = _f[_e];
                     handleSteps(steps);
                 }
             }
@@ -212,19 +233,22 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
         }
         case FormStepTypes.ENTITYVALUEPICKER:
             if (idModifier) {
-                for (const path of step.path) {
+                for (var _g = 0, _h = step.path; _g < _h.length; _g++) {
+                    var path = _h[_g];
                     if (path.type === EntityValueDataTypes.STEP) {
                         path.idStep = idModifier(path.idStep);
                     }
                 }
-                for (const filter of step.filters) {
+                for (var _j = 0, _k = step.filters; _j < _k.length; _j++) {
+                    var filter = _k[_j];
                     if (filter.type === EntityValueDataTypes.STEP) {
                         filter.idStep = idModifier(filter.idStep);
                     }
                 }
             }
-            for (const idOption of Object.keys(step.options ?? {})) {
-                const option = step.options[idOption];
+            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];
                 if (option.type === EntityValueOptionTypes.NESTED) {
                     handleSteps(option.steps);
                 }
@@ -232,7 +256,7 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             break;
         case CBRFormStepTypes.CBR_LOCATIVAS:
             {
-                const elementStep = step;
+                var elementStep = step;
                 if (elementStep.subStep) {
                     if (idModifier)
                         elementStep.subStep = idModifier(elementStep.subStep);
@@ -241,7 +265,7 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
             }
             break;
         case AYFFormStepTypes.AYF_ICA_CITY: {
-            const cityStep = step;
+            var cityStep = step;
             if (cityStep.idNitStep) {
                 if (idModifier)
                     cityStep.idNitStep = idModifier(cityStep.idNitStep);
@@ -254,18 +278,21 @@ export const calcSubSteps = (idStep, allSteps, idModifier) => {
     }
     return subSteps;
 };
-export const evaluateCondition = (condition, dependencies, entityValue) => {
+export var evaluateCondition = function (condition, dependencies, entityValue) {
+    var _a, _b, _c;
     switch (condition.type) {
         case ConditionTypes.EXPRESSION: {
             if (condition.expression === ExpressionTypes.OR) {
-                for (const subCondition of condition.conditions) {
+                for (var _i = 0, _d = condition.conditions; _i < _d.length; _i++) {
+                    var subCondition = _d[_i];
                     if (evaluateCondition(subCondition, dependencies))
                         return true;
                 }
                 return false;
             }
             else {
-                for (const subCondition of condition.conditions) {
+                for (var _e = 0, _f = condition.conditions; _e < _f.length; _e++) {
+                    var subCondition = _f[_e];
                     if (!evaluateCondition(subCondition, dependencies))
                         return false;
                 }
@@ -274,14 +301,14 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
         }
         case ConditionTypes.FORM_STEP: {
             if (isFormStepExistance(condition)) {
-                const boolFactor = condition.operator === OperatorTypes.EXISTS;
-                const value = dependencies[condition.idStep].value;
-                if (value)
+                var boolFactor = condition.operator === OperatorTypes.EXISTS;
+                var value_1 = dependencies[condition.idStep].value;
+                if (value_1)
                     return boolFactor;
                 return !boolFactor;
             }
-            const dependency = dependencies[condition.idStep];
-            const value = dependencies[condition.idStep].value;
+            var dependency = dependencies[condition.idStep];
+            var value_2 = dependencies[condition.idStep].value;
             switch (condition.stepType) {
                 // case FormStepTypes.AGENTPICKER:
                 //     return await evaluateAgentCondition(
@@ -289,24 +316,25 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
                 //         value as string[]
                 //     );
                 case FormStepTypes.CHECKBOX: {
-                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    return value === condition.value ? boolFactor : !boolFactor;
+                    var boolFactor = condition.operator === OperatorTypes.EQUAL;
+                    return value_2 === condition.value ? boolFactor : !boolFactor;
                 }
                 case FormStepTypes.TIMEPICKER: {
-                    const boolFactor = condition.operator === OperatorTypes.INCLUDES;
-                    if (!value)
+                    var boolFactor = condition.operator === OperatorTypes.INCLUDES;
+                    if (!value_2)
                         return !boolFactor;
-                    const evaluateCondition = (condition) => {
-                        const property = condition.property;
+                    var evaluateCondition_1 = function (condition) {
+                        var property = condition.property;
                         if (property === 'working') {
-                            const boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
-                            if (value.working === condition.value) {
-                                return boolFactor;
+                            var boolFactor_1 = condition.propertyOperator ===
+                                OperatorTypes.EQUAL;
+                            if (value_2.working === condition.value) {
+                                return boolFactor_1;
                             }
-                            return !boolFactor;
+                            return !boolFactor_1;
                         }
                         else {
-                            const time = value;
+                            var time = value_2;
                             switch (condition.propertyOperator) {
                                 case OperatorTypes.EQUAL: {
                                     return time[property] === condition.value;
@@ -315,13 +343,13 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
                                     return time[property] !== condition.value;
                                 }
                                 case OperatorTypes.LESS: {
-                                    const propValue = time[property];
+                                    var propValue = time[property];
                                     if (!propValue)
                                         return false;
                                     return propValue < condition.value;
                                 }
                                 case OperatorTypes.MORE: {
-                                    const propValue = time[property];
+                                    var propValue = time[property];
                                     if (!propValue)
                                         return false;
                                     return propValue > condition.value;
@@ -332,28 +360,34 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
                             }
                         }
                     };
-                    return evaluateCondition(condition) ? boolFactor : !boolFactor;
+                    return evaluateCondition_1(condition)
+                        ? boolFactor
+                        : !boolFactor;
                 }
                 case FormStepTypes.DATEPICKER: {
-                    if (!(value instanceof Date) || isNaN(value.getTime())) {
+                    if (!(value_2 instanceof Date) || isNaN(value_2.getTime())) {
                         return condition.operator === OperatorTypes.NOTEQUAL;
                     }
-                    const propertyDate = new Date(condition.value);
+                    var propertyDate = new Date(condition.value);
                     switch (condition.operator) {
                         case OperatorTypes.EQUAL:
-                            return value.toUTCString().split('T')[0] === propertyDate.toUTCString().split('T')[0];
+                            return (value_2.toUTCString().split('T')[0] ===
+                                propertyDate.toUTCString().split('T')[0]);
                         case OperatorTypes.NOTEQUAL:
-                            return value.toUTCString().split('T')[0] !== propertyDate.toUTCString().split('T')[0];
+                            return (value_2.toUTCString().split('T')[0] !==
+                                propertyDate.toUTCString().split('T')[0]);
                         case OperatorTypes.LESS:
-                            return value.getTime() < propertyDate.getTime();
+                            return value_2.getTime() < propertyDate.getTime();
                         case OperatorTypes.MORE:
-                            return value.getTime() > propertyDate.getTime();
+                            return value_2.getTime() > propertyDate.getTime();
                         default:
                             return false;
                     }
                 }
                 case FormStepTypes.SELECTOR: {
-                    const val = dependency.type === 'ORIGINAL' ? value : (value?.value ?? null);
+                    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;
                     if (condition.operator === OperatorTypes.EQUAL) {
                         return condition.value === val;
                     }
@@ -363,58 +397,61 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
                 }
                 case FormStepTypes.TEXTINPUT: {
                     if (condition.operator === OperatorTypes.INCLUDES) {
-                        return value?.toLowerCase()?.includes(condition.value.toLowerCase());
+                        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());
                     }
                     else if (condition.operator === OperatorTypes.NOTINCLUDES) {
-                        return !value?.toLowerCase()?.includes(condition.value.toLowerCase());
+                        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()));
                     }
                     else if (condition.operator === OperatorTypes.EQUAL) {
-                        return condition.value.toLowerCase() === value?.toLowerCase();
+                        return (condition.value.toLowerCase() ===
+                            (value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()));
                     }
                     else if (condition.operator === OperatorTypes.NOTEQUAL) {
-                        return !(condition.value.toLowerCase() === value?.toLowerCase());
+                        return !(condition.value.toLowerCase() ===
+                            (value_2 === null || value_2 === void 0 ? void 0 : value_2.toLowerCase()));
                     }
                     else {
                         return false;
                     }
                 }
                 case FormStepTypes.TEXTAREA: {
-                    const words = condition.values;
-                    let regx = `\\b(${words[0].toLowerCase()}`;
-                    for (let i = 1; i < words.length; i++) {
-                        regx += `|${words[i].toLowerCase()}`;
+                    var words = condition.values;
+                    var regx = "\\b(".concat(words[0].toLowerCase());
+                    for (var i = 1; i < words.length; i++) {
+                        regx += "|".concat(words[i].toLowerCase());
                     }
                     regx += ')\\b';
                     if (condition.operator === OperatorTypes.INCLUDES) {
-                        return value && new RegExp(regx).test(value.toLowerCase());
+                        return (value_2 && new RegExp(regx).test(value_2.toLowerCase()));
                     }
                     else {
-                        return !value || !new RegExp(regx).test(value.toLowerCase());
+                        return (!value_2 ||
+                            !new RegExp(regx).test(value_2.toLowerCase()));
                     }
                 }
                 case FormStepTypes.RATING: {
-                    if (!value || isNaN(value)) {
+                    if (!value_2 || isNaN(value_2)) {
                         return condition.operator === OperatorTypes.NOTEQUAL;
                     }
                     switch (condition.operator) {
                         case OperatorTypes.EQUAL:
                         case OperatorTypes.NOTEQUAL: {
-                            const boolFactor = condition.operator === OperatorTypes.EQUAL;
-                            if (value === condition.value)
+                            var boolFactor = condition.operator === OperatorTypes.EQUAL;
+                            if (value_2 === condition.value)
                                 return boolFactor;
                             return !boolFactor;
                         }
                         case OperatorTypes.LESS:
-                            return value < condition.value;
+                            return value_2 < condition.value;
                         case OperatorTypes.MORE:
-                            return value > condition.value;
+                            return value_2 > condition.value;
                         default:
                             return false;
                     }
                 }
                 case FormStepTypes.CLASSIFIER_SELECTOR: {
-                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    if (value?.value === condition.idValue) {
+                    var boolFactor = condition.operator === OperatorTypes.EQUAL;
+                    if ((value_2 === null || value_2 === void 0 ? void 0 : value_2.value) === condition.idValue) {
                         //Si op es EQUALS (boolfactor true) evaluará a true
                         //Si op es NOTEQUALS (boolfactor false) evaluará a false
                         return boolFactor;
@@ -424,9 +461,10 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
                     return !boolFactor;
                 }
                 case FormStepTypes.ENTITYVALUEPICKER: {
-                    const boolFactor = condition.operator === OperatorTypes.EQUAL;
-                    for (const idEntityValue of condition.values) {
-                        if (value?._id === idEntityValue) {
+                    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) {
                             return boolFactor;
                         }
                     }
@@ -438,7 +476,7 @@ export const evaluateCondition = (condition, dependencies, entityValue) => {
             break;
         }
         case ConditionTypes.ENTITYVALUE: {
-            if (!entityValue?.entity)
+            if (!entityValue || !entityValue.entity)
                 return false;
             return evaluateEntityValueCondition(condition, entityValue.entity, entityValue.entityValue);
         }
@@ -448,14 +486,16 @@ export const evaluateCondition = (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);
 }
-const evaluateEntityValueCondition = (condition, entity, entityValue) => {
+var evaluateEntityValueCondition = function (condition, entity, entityValue) {
     switch (condition.operator) {
         case OperatorTypes.EQUAL:
         case OperatorTypes.NOTEQUAL: {
-            const boolFactor = condition.operator === OperatorTypes.EQUAL;
-            for (const value of condition.values) {
+            var boolFactor = condition.operator === OperatorTypes.EQUAL;
+            for (var _i = 0, _a = condition.values; _i < _a.length; _i++) {
+                var value = _a[_i];
                 if (value === entityValue._id) {
                     return boolFactor;
                 }
@@ -473,80 +513,87 @@ const evaluateEntityValueCondition = (condition, entity, entityValue) => {
     }
     return false;
 };
-const evaluateEntityPropertyCondition = (condition, entity, entityValue) => {
+var evaluateEntityPropertyCondition = function (condition, entity, entityValue) {
+    var _a, _b, _c;
     if (isEntityPropertyExistance(condition)) {
-        const boolFactor = condition.propertyOperator === OperatorTypes.EXISTS;
-        const value = entityValue[condition.idProperty];
-        if (value !== undefined) {
+        var boolFactor = condition.propertyOperator === OperatorTypes.EXISTS;
+        var value_3 = entityValue[condition.idProperty];
+        if (value_3 !== undefined) {
             return boolFactor;
         }
         return !boolFactor;
     }
-    const property = entity.steps[condition.idProperty];
+    var property = entity.steps[condition.idProperty];
     if (!property || property.type !== condition.propertyType) {
         return false;
     }
-    const value = entityValue[condition.idProperty];
+    var value = entityValue[condition.idProperty];
     if (value === undefined)
         return false;
     switch (condition.propertyType) {
         case EntityPropertyTypes.CHECKBOX: {
-            const boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
+            var boolFactor = condition.propertyOperator === OperatorTypes.EQUAL;
             if (value === condition.propertyValue) {
                 return boolFactor;
             }
             return !boolFactor;
         }
         case EntityPropertyTypes.DATEPICKER: {
-            const date = new Date(value);
+            var date = new Date(value);
             if (!(date instanceof Date) || isNaN(date.getTime())) {
                 return condition.propertyOperator === OperatorTypes.NOTEQUAL;
             }
             switch (condition.propertyOperator) {
                 case OperatorTypes.EQUAL: {
-                    const propertyDate = new Date(condition.propertyValue);
+                    var propertyDate = new Date(condition.propertyValue);
                     return date.getTime() === propertyDate.getTime();
                 }
                 case OperatorTypes.NOTEQUAL: {
-                    const propertyDate = new Date(condition.propertyValue);
+                    var propertyDate = new Date(condition.propertyValue);
                     return date.getTime() !== propertyDate.getTime();
                 }
                 case OperatorTypes.LESS: {
-                    const propertyDate = new Date(condition.propertyValue);
+                    var propertyDate = new Date(condition.propertyValue);
                     return date.getTime() < propertyDate.getTime();
                 }
                 case OperatorTypes.MORE: {
-                    const propertyDate = new Date(condition.propertyValue);
+                    var 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: {
-                    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();
+                    var date_1 = getRelativeDate((_a = condition.value) === null || _a === void 0 ? void 0 : _a.days, (_b = condition.value) === null || _b === void 0 ? void 0 : _b.hours, (_c = condition.value) === null || _c === void 0 ? void 0 : _c.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(value).getTime() < date_1.getTime();
                     else
-                        return new Date().getTime() < date.getTime();
+                        return new Date(value).getTime() > date_1.getTime();
                 }
+                default:
+                    false;
             }
             return false;
         }
         case EntityPropertyTypes.TIMEPICKER: {
-            const boolFactor = condition.propertyOperator === OperatorTypes.INCLUDES;
-            const evaluateCondition = (condition) => {
-                const timeProperty = condition.property;
+            var boolFactor = condition.propertyOperator === OperatorTypes.INCLUDES;
+            var evaluateCondition_2 = function (condition) {
+                var timeProperty = condition.property;
                 if (timeProperty === 'working') {
-                    const boolFactor = condition.timePropertyOperator === OperatorTypes.EQUAL;
+                    var boolFactor_2 = condition.timePropertyOperator === OperatorTypes.EQUAL;
                     if (value.working === condition.value) {
-                        return boolFactor;
+                        return boolFactor_2;
                     }
-                    return !boolFactor;
+                    return !boolFactor_2;
                 }
                 else {
-                    const time = value;
+                    var time = value;
                     switch (condition.timePropertyOperator) {
                         case OperatorTypes.EQUAL: {
                             return time[timeProperty] === condition.value;
@@ -555,13 +602,13 @@ const evaluateEntityPropertyCondition = (condition, entity, entityValue) => {
                             return time[timeProperty] !== condition.value;
                         }
                         case OperatorTypes.LESS: {
-                            const propValue = time[timeProperty];
+                            var propValue = time[timeProperty];
                             if (!propValue)
                                 return false;
                             return propValue < condition.value;
                         }
                         case OperatorTypes.MORE: {
-                            const propValue = time[timeProperty];
+                            var propValue = time[timeProperty];
                             if (!propValue)
                                 return false;
                             return propValue > condition.value;
@@ -572,17 +619,17 @@ const evaluateEntityPropertyCondition = (condition, entity, entityValue) => {
                     }
                 }
             };
-            return evaluateCondition(condition) ? boolFactor : !boolFactor;
+            return evaluateCondition_2(condition) ? boolFactor : !boolFactor;
         }
         case EntityPropertyTypes.SELECTOR:
         case EntityPropertyTypes.TEXTAREA:
         case EntityPropertyTypes.TEXTINPUT: {
             if (condition.propertyOperator === OperatorTypes.INCLUDES ||
                 condition.propertyOperator === OperatorTypes.NOTINCLUDES) {
-                const words = condition.propertyValues;
-                let regx = `\\b(${words[0].toLowerCase()}`;
-                for (let i = 1; i < words.length; i++) {
-                    regx += `|${words[i].toLowerCase()}`;
+                var words = condition.propertyValues;
+                var regx = "\\b(".concat(words[0].toLowerCase());
+                for (var i = 1; i < words.length; i++) {
+                    regx += "|".concat(words[i].toLowerCase());
                 }
                 regx += ')\\b';
                 if (condition.propertyOperator === OperatorTypes.INCLUDES) {
@@ -594,10 +641,12 @@ const evaluateEntityPropertyCondition = (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;
         }
@@ -607,9 +656,15 @@ const evaluateEntityPropertyCondition = (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 = 0, nHours = 0, nMinutes = 0, subtract = false, date = new Date()) {
-    const millis = nDays * 86400000 + nHours * 3600000 + nMinutes * 60000;
+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;
     return new Date(date.getTime() + (subtract ? -millis : millis));
 }