@zohodesk/library-platform 1.1.1 → 1.1.2-exp.1

package/es/platform/zform/frameworks/ui/ZFormBehaviourFactory.js

@@ -0,0 +1,31 @@
+import Properties from "../../../../bc/zform/Properties";
+import EventHandlerFactory from "./EventHandlerFactory";
+
+class ZFormBehaviourFactory {
+  static create(_ref) {
+    let {
+      customValidators
+    } = _ref;
+    return {
+      name: 'zform',
+      setInitialState: _ref2 => {
+        let {
+          properties
+        } = _ref2;
+        return {
+          isMyFormFetching: true,
+          isDependencyFetching: true,
+          isLayoutRulesFetching: true,
+          isValidationRulesFetching: true
+        };
+      },
+      properties: Properties,
+      eventHandlers: EventHandlerFactory.create({
+        customValidators
+      })
+    };
+  }
+
+}
+
+export default ZFormBehaviourFactory;

package/es/platform/zform/frameworks/validation-rules/Validator.js

@@ -0,0 +1,44 @@
+import getValidationRuleActionsData from "./validationRules"; //need to move to gateway in adapter
+
+export default class Validator {
+  constructor(customValidators) {
+    this.customValidators = customValidators;
+  }
+
+  validateAsync(_ref) {
+    let {
+      formData,
+      myForm,
+      validationRules
+    } = _ref;
+    let fieldDetails = {};
+    let fieldMapper = {};
+    const formUIData = {};
+    myForm.sections.forEach(section => {
+      section.fields.forEach(field => {
+        fieldDetails[field.id] = field;
+        fieldMapper[field.apiName] = field.id;
+        formUIData[field.id] = { ...field,
+          value: formData[field.apiName].value || null,
+          isShowOnLayoutRuleApplied: true //hack
+
+        };
+      });
+    });
+    const formFields = {
+      fieldDetails,
+      fieldMapper
+    };
+    let result = getValidationRuleActionsData(validationRules, formUIData, formFields, this.customValidators);
+    let output = {};
+    Object.keys(result.data).forEach(key => {
+      if (!output[fieldDetails[key].apiName]) {
+        output[fieldDetails[key].apiName] = {};
+      }
+
+      output[fieldDetails[key].apiName].errorMessage = result.data[key].validationRuleMessage;
+    });
+    return Promise.resolve(output); // throw new Error("Method not implemented.");
+  }
+
+}

package/es/platform/zform/frameworks/validation-rules/expressionEval.js

@@ -0,0 +1,123 @@
+import jsep from 'jsep';
+/**
+ * Evaluation code from JSEP project, under MIT License.
+ * Copyright (c) 2013 Stephen Oney, http://jsep.from.so/
+ */
+
+const binops = {
+  '||': function (a, b) {
+    return a || b;
+  },
+  '&&': function (a, b) {
+    return a && b;
+  } // '|':   function (a, b) { return a | b; },
+  // '^':   function (a, b) { return a ^ b; },
+  // '&':   function (a, b) { return a & b; },
+  // '==':  function (a, b) { return a == b; }, // jshint ignore:line
+  // '!=':  function (a, b) { return a != b; }, // jshint ignore:line
+  // '===': function (a, b) { return a === b; },
+  // '!==': function (a, b) { return a !== b; },
+  // '<':   function (a, b) { return a < b; },
+  // '>':   function (a, b) { return a > b; },
+  // '<=':  function (a, b) { return a <= b; },
+  // '>=':  function (a, b) { return a >= b; },
+  // '<<':  function (a, b) { return a << b; },
+  // '>>':  function (a, b) { return a >> b; },
+  // '>>>': function (a, b) { return a >>> b; },
+  // '+':   function (a, b) { return a + b; },
+  // '-':   function (a, b) { return a - b; },
+  // '*':   function (a, b) { return a * b; },
+  // '/':   function (a, b) { return a / b; },
+  // '%':   function (a, b) { return a % b; }
+
+};
+const unops = {
+  '-': function (a) {
+    return -a;
+  },
+  '+': function (a) {
+    return +a;
+  },
+  '~': function (a) {
+    return ~a;
+  },
+  '!': function (a) {
+    return !a;
+  }
+};
+
+function evaluateArray(list, context) {
+  return list.map(v => evaluate(v, context));
+}
+
+function evaluateMember(node, context) {
+  const object = evaluate(node.object, context);
+
+  if (node.computed) {
+    return [object, object[evaluate(node.property, context)]];
+  }
+
+  return [object, object[node.property.name]];
+}
+
+function evaluate(node, context) {
+  switch (node.type) {
+    case 'ArrayExpression':
+      return evaluateArray(node.elements, context);
+
+    case 'BinaryExpression':
+      return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+
+    case 'CallExpression':
+      let caller;
+      let fn;
+      let assign;
+
+      if (node.callee.type === 'MemberExpression') {
+        assign = evaluateMember(node.callee, context);
+        caller = assign[0];
+        fn = assign[1];
+      } else {
+        fn = evaluate(node.callee, context);
+      }
+
+      if (typeof fn !== 'function') {
+        return undefined;
+      }
+
+      return fn.apply(caller, evaluateArray(node.arguments, context));
+
+    case 'ConditionalExpression':
+      return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+
+    case 'Identifier':
+    case 'Literal':
+      return context[node.value];
+    // return node.value;
+
+    case 'LogicalExpression':
+      if (node.operator === '||') {
+        return evaluate(node.left, context) || evaluate(node.right, context);
+      }
+
+      if (node.operator === '&&') {
+        return evaluate(node.left, context) && evaluate(node.right, context);
+      }
+
+      return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+
+    case 'MemberExpression':
+      return evaluateMember(node, context)[1];
+
+    case 'ThisExpression':
+      return context;
+
+    case 'UnaryExpression':
+      return unops[node.operator](evaluate(node.argument, context));
+
+    default:
+      return undefined;
+  }
+}
+
+export { jsep as parse, evaluate as evaluateExpression };