@zohodesk/library-platform 1.0.1 → 1.0.2-exp.1.1

package/es/platform/zform/frameworks/layout-rules/getLayoutRuleAppliedSectionProperties.js

@@ -0,0 +1,35 @@
+export function getLayoutRuleAppliedSectionProperties(_ref) {
+  let {
+    sectionId,
+    sectionMeta,
+    layoutRulesResult
+  } = _ref;
+  const visibility = getSectionVisibility({
+    layoutRulesResult,
+    sectionId,
+    defaultValue: sectionMeta.visibility
+  });
+  const section = {
+    visibility
+  };
+  return section;
+}
+export function getSectionVisibility(_ref2) {
+  let {
+    layoutRulesResult,
+    sectionId,
+    defaultValue
+  } = _ref2;
+
+  // const layoutRulesResult = calculateLayoutRulesResult(state);
+  if (!layoutRulesResult || !layoutRulesResult.showSectionIdsMap) {
+    return defaultValue;
+  }
+
+  const {
+    showSectionIdsMap
+  } = layoutRulesResult;
+  const isSectionShowByLayoutRule = showSectionIdsMap[sectionId];
+  const visibility = isSectionShowByLayoutRule === false ? false : isSectionShowByLayoutRule === true ? true : defaultValue;
+  return visibility;
+}

package/es/platform/zform/frameworks/layout-rules/runSingleFieldCondition.js

@@ -0,0 +1,60 @@
+import { validateCondition as _validateCondition } from "./validator";
+import { validatePattern } from "./expressionEval";
+import validationTypeMapper from "./validationTypeMapper";
+
+function validateCondition(fieldType, conditionName, values, formValue, statusMapping) {
+  const validate = value => _validateCondition(fieldType, conditionName, value, formValue, statusMapping);
+
+  if (conditionName === 'between' || conditionName === 'not between') {
+    return validate(values);
+  } else if (conditionName === "isn't" || conditionName === "doesn't contain") {
+    return values.every(val => validate(val));
+  } else {
+    return values.some(value => validate(value));
+  }
+}
+
+export function runSingleFieldCondition(_ref) {
+  let {
+    fieldCondition,
+    fields,
+    formValues
+  } = _ref;
+  const {
+    conditions,
+    pattern
+  } = fieldCondition;
+  const matchedResult = {};
+  let isSomeFiledMissing = false;
+  conditions.forEach((conditionObj, i) => {
+    const {
+      condition,
+      value,
+      fieldName
+    } = conditionObj;
+
+    if (!fields[fieldName]) {
+      isSomeFiledMissing = true;
+    }
+
+    const {
+      type
+    } = fields[fieldName]; // Revalidate: do we need to support type that are not in mapping
+
+    const fieldType = validationTypeMapper[type] || type;
+    const resultConditions = validateCondition(fieldType, condition, value, fieldType === "Picklist" ? getSelectedOptionIdFromSelectFieldValue(formValues[fieldName]) : formValues[fieldName]);
+    matchedResult[i + 1] = !!resultConditions;
+  });
+
+  if (isSomeFiledMissing) {
+    return null;
+  }
+
+  const isConditionsPassed = validatePattern(pattern, matchedResult);
+  return isConditionsPassed ? fieldCondition : null;
+}
+
+function getSelectedOptionIdFromSelectFieldValue(val) {
+  const selectedId = !val || typeof val === 'string' ? val : typeof val.id !== 'string' ? typeof val.value !== 'string' ? val.value.id : val.value : val.id;
+  return selectedId;
+}

package/es/platform/zform/frameworks/layout-rules/selectors.js

@@ -0,0 +1,9 @@
+import selectn from 'selectn';
+export function getLayoutRules(state) {
+  const layoutRules = selectn('layoutRules.rules', state);
+  return layoutRules;
+}
+export function getLayoutRulesResult(state) {
+  const results = selectn('layoutRules.results', state);
+  return results;
+}

package/es/platform/zform/frameworks/layout-rules/validationTypeMapper.js

@@ -0,0 +1,20 @@
+export default {
+  TextBox: 'Text',
+  TextArea: 'Textarea',
+  CheckBox: 'Boolean',
+  Date: 'Date',
+  // DateTime: 'DateTime',
+  // RADIO: 'Radio',
+  // FAX: 'Fax',
+  Url: 'URL',
+  // LOOKUP: 'LookUp',
+  Email: 'Email',
+  Phone: 'Phone',
+  Integer: 'Number',
+  Percent: 'Percent',
+  Decimal: 'Decimal',
+  Currency: 'Currency',
+  // Revalidate: Select, MultiSelect
+  Select: 'Picklist' // MultiSelect: 'MultiSelect'
+
+};

package/es/platform/zform/frameworks/layout-rules/validator.js

@@ -0,0 +1,331 @@
+// Copied from desk_client_repo
+const Types = {
+  TEXT: 'Text',
+  EMAIL: 'Email',
+  PHONE: 'Phone',
+  URL: 'URL',
+  TEXTAREA: 'Textarea',
+  LOOKUP: 'LookUp',
+  NUMBER: 'Number',
+  PERCENT: 'Percent',
+  CURRENCY: 'Currency',
+  DECIMAL: 'Decimal',
+  BOOLEAN: 'Boolean',
+  DATETIME: 'DateTime',
+  DATE: 'Date',
+  PICKLIST: 'Picklist',
+  RADIO: 'Radio',
+  FAX: 'Fax'
+};
+const COMMON_COMPARATORS = {
+  ISEMPTY: 'is empty',
+  ISNOTEMPTY: 'is not empty'
+};
+const TEXT_COMPARATORS = {
+  IS: 'is',
+  ISNT: "isn't",
+  STARTSWITH: 'starts with',
+  ENDSWITH: 'ends with',
+  CONTAINS: 'contains',
+  DOESNTCONTAIN: "doesn't contain"
+};
+const NUMBER_COMPARATORS = {
+  EQUAL: '=',
+  NOTEQUAL: '<>',
+  LESSTHAN: '<',
+  LESSTHANEQUAL: '<=',
+  GREATERTHAN: '>',
+  GREATERTHANEQUAL: '>='
+};
+const DATE_COMPARATORS = {
+  ISAFTER: 'is after',
+  ISBEFORE: 'is before',
+  BETWEEN: 'between',
+  NOTBETWEEN: 'not between'
+};
+const STATUS_COMPARATORS = {
+  ISOPEN: 'is OPEN',
+  ISONHOLD: 'is ON HOLD',
+  ISCLOSED: 'is CLOSED',
+  ISCOMPLETED: 'is COMPLETED'
+};
+
+const validateText = function () {
+  let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let matched = false;
+
+  if (condition === COMMON_COMPARATORS.ISEMPTY) {
+    matched = formValue === '';
+  } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+    matched = formValue !== '';
+  } else {
+    value = value !== null ? value.toLowerCase().trim() : '';
+    formValue = formValue !== null ? formValue.toLowerCase().trim() : '';
+
+    switch (condition) {
+      case TEXT_COMPARATORS.IS:
+        matched = formValue === value;
+        break;
+
+      case TEXT_COMPARATORS.ISNT:
+        matched = formValue !== value;
+        break;
+
+      case TEXT_COMPARATORS.STARTSWITH:
+        matched = formValue.startsWith(value);
+        break;
+
+      case TEXT_COMPARATORS.ENDSWITH:
+        matched = formValue.endsWith(value);
+        break;
+
+      case TEXT_COMPARATORS.CONTAINS:
+        matched = formValue.indexOf(value) !== -1;
+        break;
+
+      case TEXT_COMPARATORS.DOESNTCONTAIN:
+        matched = formValue.indexOf(value) === -1;
+        break;
+    }
+  }
+
+  return matched;
+};
+
+const validateNumber = function () {
+  let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let matched = false;
+
+  if (condition === COMMON_COMPARATORS.ISEMPTY) {
+    matched = formValue === '';
+  } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+    matched = formValue !== '';
+  } else {
+    if (formValue === '') {
+      return false;
+    }
+
+    value = parseFloat(value);
+    formValue = parseFloat(formValue);
+
+    switch (condition) {
+      case NUMBER_COMPARATORS.EQUAL:
+        matched = formValue === value;
+        break;
+
+      case NUMBER_COMPARATORS.NOTEQUAL:
+        matched = formValue !== value;
+        break;
+
+      case NUMBER_COMPARATORS.LESSTHAN:
+        matched = formValue < value;
+        break;
+
+      case NUMBER_COMPARATORS.LESSTHANEQUAL:
+        matched = formValue <= value;
+        break;
+
+      case NUMBER_COMPARATORS.GREATERTHAN:
+        matched = formValue > value;
+        break;
+
+      case NUMBER_COMPARATORS.GREATERTHANEQUAL:
+        matched = formValue >= value;
+        break;
+    }
+  }
+
+  return matched;
+};
+
+const validateBoolean = function () {
+  let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  formValue = String(formValue) || 'false';
+  value = String(value) || 'false';
+  let matched = false;
+
+  switch (condition) {
+    case TEXT_COMPARATORS.IS:
+      matched = formValue === value;
+      break;
+  }
+
+  return matched;
+};
+
+const validateDate = function () {
+  let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let matched = false;
+
+  if (condition === COMMON_COMPARATORS.ISEMPTY) {
+    matched = formValue === '';
+  } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+    matched = formValue !== '';
+  } else {
+    if (formValue === '') {
+      return false;
+    }
+
+    formValue = new Date(formValue);
+
+    if (condition === DATE_COMPARATORS.BETWEEN || condition === DATE_COMPARATORS.NOTBETWEEN) {
+      const beforeVal = new Date(value[0]);
+      const afterVal = new Date(value[1]);
+
+      switch (condition) {
+        case DATE_COMPARATORS.BETWEEN:
+          matched = formValue.getTime() - beforeVal.getTime() >= 0 && formValue.getTime() - afterVal.getTime() <= 0;
+          break;
+
+        case DATE_COMPARATORS.NOTBETWEEN:
+          matched = !(formValue.getTime() - beforeVal.getTime() >= 0 && formValue.getTime() - afterVal.getTime() <= 0);
+          break;
+      }
+    } else {
+      value = new Date(value);
+
+      switch (condition) {
+        case TEXT_COMPARATORS.IS:
+          matched = formValue.getTime() - value.getTime() === 0;
+          break;
+
+        case TEXT_COMPARATORS.ISNT:
+          matched = formValue !== '' && formValue.getTime() - value.getTime() !== 0;
+          break;
+
+        case DATE_COMPARATORS.ISAFTER:
+          matched = formValue.getTime() - value.getTime() > 0;
+          break;
+
+        case DATE_COMPARATORS.ISBEFORE:
+          matched = formValue.getTime() - value.getTime() < 0;
+          break;
+      }
+    }
+  }
+
+  return matched;
+};
+
+const validatePicklist = function () {
+  let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let statusMapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+  if ([STATUS_COMPARATORS.ISOPEN, STATUS_COMPARATORS.ISONHOLD, STATUS_COMPARATORS.ISCLOSED, STATUS_COMPARATORS.ISCOMPLETED].indexOf(condition) !== -1) {
+    let matched = false;
+
+    switch (condition) {
+      case STATUS_COMPARATORS.ISOPEN:
+        matched = statusMapping.open.indexOf(formValue) !== -1;
+        break;
+
+      case STATUS_COMPARATORS.ISONHOLD:
+        matched = statusMapping.onhold.indexOf(formValue) !== -1;
+        break;
+
+      case STATUS_COMPARATORS.ISCLOSED:
+        matched = statusMapping.closed.indexOf(formValue) !== -1;
+        break;
+
+      case STATUS_COMPARATORS.ISCOMPLETED:
+        matched = statusMapping.completed.indexOf(formValue) !== -1;
+        break;
+    }
+
+    return matched;
+  }
+
+  formValue = formValue === '-None-' ? null : formValue;
+  return validateText(condition, value, formValue);
+};
+
+const getRelatedDateISOString = (dateValue, isDateField) => {
+  if (dateValue === '${CURRENTTIME}') {
+    let currentDateObj = new Date();
+    dateValue = currentDateObj.toISOString();
+  }
+
+  if (isDateField) {
+    dateValue += 'T00:00:00.000Z';
+  } else {
+    let dateObj = new Date(dateValue);
+    dateObj.setSeconds(0);
+    dateObj.setMilliseconds(0);
+    dateValue = dateObj.toISOString();
+  }
+
+  return dateValue;
+};
+
+export const comparators_contants = {
+  COMMON_COMPARATORS,
+  TEXT_COMPARATORS,
+  NUMBER_COMPARATORS,
+  DATE_COMPARATORS,
+  STATUS_COMPARATORS
+};
+export function validateCondition() {
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let condition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let formValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+  let statusMapping = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  {
+    formValue = formValue === null ? '' : formValue;
+
+    switch (type) {
+      case Types.TEXT:
+      case Types.EMAIL:
+      case Types.PHONE:
+      case Types.URL:
+      case Types.TEXTAREA:
+      case Types.LOOKUP:
+      case Types.FAX:
+        return validateText(condition, value, formValue);
+
+      case Types.NUMBER:
+      case Types.PERCENT:
+      case Types.CURRENCY:
+      case Types.DECIMAL:
+        return validateNumber(condition, value, formValue);
+
+      case Types.BOOLEAN:
+        return validateBoolean(condition, value, formValue);
+
+      case Types.DATETIME:
+      case Types.DATE:
+        if (condition !== COMMON_COMPARATORS.ISNOTEMPTY && condition !== COMMON_COMPARATORS.ISEMPTY) {
+          if (type === Types.DATE) {
+            value = getRelatedDateISOString(value, true);
+          } else {
+            if (condition === DATE_COMPARATORS.BETWEEN || condition === DATE_COMPARATORS.NOTBETWEEN) {
+              value[0] = getRelatedDateISOString(value[0], false);
+              value[1] = getRelatedDateISOString(value[1], false);
+            } else {
+              resultConditions;
+              value = getRelatedDateISOString(value, false);
+            }
+          }
+        }
+
+        return validateDate(condition, value, formValue);
+
+      case Types.PICKLIST:
+      case Types.RADIO:
+        return validatePicklist(condition, value, formValue, statusMapping);
+
+      default:
+        return false;
+    }
+  }
+}

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

@@ -0,0 +1,226 @@
+import { ZFORM_SUBMIT } from "../../../../bc/zform/Constants";
+import FormSubmitController from "../../adapters/controllers/FormSubmitController";
+import FormRepository from "../../adapters/gateway/FormRepository";
+import FormPresenter from "../../adapters/presenter/FormPresenter";
+import Service from "../../adapters/gateway/Service";
+import LifeCycleAction from "../../../../cc/architecture/LifeCycleActionEnum";
+import InitializeController from "../../adapters/controllers/IntializeController";
+import { ZFORM_DEPENDENCY_MAPPINGS_REQUEST, ZFORM_DEPENDENCY_MAPPINGS_SUCCESS, ZFORM_FIELD_VALUE_CHANGE_REQUEST, ZFORM_MY_FORM_REQUEST, ZFORM_MY_FORM_SUCCESS, ZFORM_MY_LAYOUTS_SUCCESS, ZFORM_SET_FIELD_ERROR_MESSAGE, ZFORM_SUBMIT_SUCCESS, ZFORM_VALIDATE_FIELD_REQUEST, ZFORM_VALIDATE_SUBMIT_FIELD_HAS_ERROR_MESSAGE, ZFORM_VALIDATION_ERROR, ZFORM_VALIDATION_RULES_REQUEST, ZFORM_VALIDATION_RULES_SUCCESS } from "../../../../bc/zform/Symbol";
+import MyLayoutSuccessController from "../../adapters/controllers/MyLayoutSuccessController";
+import MyFormSuccessController from "../../adapters/controllers/MyFromSuccessController";
+import DependenciesController from "../../adapters/controllers/DependenciesController";
+import DependenciesRequestController from "../../adapters/controllers/DependenciesRequestController";
+import MyFormRequestController from "../../adapters/controllers/MyFormRequestController";
+import { ZFORM_LAYOUT_RULES_REQUEST, ZFORM_LAYOUT_RULES_SUCCESS } from "../../../../bc/zform/Symbol";
+import LayoutRulesRequestController from "../../adapters/controllers/LayoutRulesRequestController";
+import LayoutRulesSuccessController from "../../adapters/controllers/LayoutRulesSuccessController";
+import ValidationRulesRequestController from "../../adapters/controllers/ValidationRulesRequestController";
+import ValidationRulesSuccessController from "../../adapters/controllers/ValidationRulesSuccessController";
+import FieldValueChangeController from "../../adapters/controllers/FieldValueChangeController";
+import FormConstants from "../../../../cc/form/Constants";
+import ValidateFieldRequestController from "../../adapters/controllers/ValidateFieldRequestController";
+import FormValidator from "../validation-rules/Validator";
+import { FIELD_VALIDATION_RESULT, VALIDATE_FIELDS_RESULT } from "../../../../bc/field-validation/Constants";
+import SetFieldErrorMessageController from "../../adapters/controllers/SetFieldErrorMessageController";
+import LayoutRuleApplier from "../layout-rules/LayoutRuleApplier";
+import ValidateErrorMessageController from "../../adapters/controllers/ValidateErrorMessageController";
+import { CREATE_RECORD } from "../../../../bc/zrecord/Constants";
+
+class EventHandlersFactory {
+  static create(_ref) {
+    let {
+      customValidators
+    } = _ref;
+    const presenter = new FormPresenter();
+    const repository = new FormRepository();
+    const validator = new FormValidator(customValidators);
+    const layoutRuleApplier = new LayoutRuleApplier();
+    const service = new Service({
+      presenter,
+      repository,
+      validator,
+      layoutRuleApplier
+    });
+    const initializeController = new InitializeController(service);
+    const myLayoutSuccessController = new MyLayoutSuccessController(service);
+    const myFormRequestController = new MyFormRequestController(service);
+    const myFormSuccessController = new MyFormSuccessController(service);
+    const dependenciesRequestController = new DependenciesRequestController(service);
+    const dependenciesController = new DependenciesController(service);
+    const layoutRulesRequestController = new LayoutRulesRequestController(service);
+    const layoutRulesSuccessController = new LayoutRulesSuccessController(service);
+    const validationRulesRequestController = new ValidationRulesRequestController(service);
+    const validationRulesSuccessController = new ValidationRulesSuccessController(service);
+    const fieldValueChangeController = new FieldValueChangeController(service);
+    const validateFieldRequestController = new ValidateFieldRequestController(service);
+    const formSubmitController = new FormSubmitController(service);
+    const setFieldErrorMessageController = new SetFieldErrorMessageController(service);
+    const validateErrorMessageController = new ValidateErrorMessageController(service);
+    return {
+      [LifeCycleAction.MOUNT]: initializeController.handle,
+      [ZFORM_MY_LAYOUTS_SUCCESS]: myLayoutSuccessController.handle,
+      [ZFORM_MY_FORM_REQUEST]: myFormRequestController.handle,
+      [ZFORM_MY_FORM_SUCCESS]: myFormSuccessController.handle,
+      [ZFORM_DEPENDENCY_MAPPINGS_REQUEST]: dependenciesRequestController.handle,
+      [ZFORM_DEPENDENCY_MAPPINGS_SUCCESS]: dependenciesController.handle,
+      [ZFORM_LAYOUT_RULES_REQUEST]: layoutRulesRequestController.handle,
+      [ZFORM_LAYOUT_RULES_SUCCESS]: layoutRulesSuccessController.handle,
+      [ZFORM_VALIDATION_RULES_REQUEST]: validationRulesRequestController.handle,
+      [ZFORM_VALIDATION_RULES_SUCCESS]: validationRulesSuccessController.handle,
+      [ZFORM_FIELD_VALUE_CHANGE_REQUEST]: fieldValueChangeController.handle,
+      [ZFORM_SET_FIELD_ERROR_MESSAGE]: setFieldErrorMessageController.handle,
+      [ZFORM_VALIDATE_FIELD_REQUEST]: validateFieldRequestController.handle,
+      [ZFORM_SUBMIT]: formSubmitController.handle,
+      [ZFORM_SUBMIT_SUCCESS]: _ref2 => {
+        let {
+          action,
+          state,
+          updateState,
+          dispatch
+        } = _ref2;
+        let formData = action.payload.formData;
+        let moduleName = state.properties.moduleName;
+        let record = {
+          cf: {}
+        };
+        Object.keys(formData).forEach(key => {
+          if (key.startsWith("cf_")) {
+            record.cf[key] = formData[key];
+          } else {
+            record[key] = formData[key];
+          }
+        });
+        dispatch({
+          type: CREATE_RECORD,
+          payload: {
+            record,
+            moduleName: moduleName
+          }
+        });
+      },
+      [ZFORM_VALIDATION_ERROR]: _ref3 => {
+        let {
+          action,
+          state,
+          updateState,
+          dispatch
+        } = _ref3;
+        let formData = { ...state.behaviours.zform.formData
+        };
+        Object.keys(action.payload).forEach(key => {
+          dispatch({
+            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+            payload: {
+              fieldApiName: key,
+              errorMessage: action.payload[key].errorMessage
+            }
+          });
+        });
+      },
+      [ZFORM_VALIDATE_SUBMIT_FIELD_HAS_ERROR_MESSAGE]: validateErrorMessageController.handle,
+      [FIELD_VALIDATION_RESULT]: _ref4 => {
+        let {
+          action,
+          state,
+          updateState,
+          dispatch
+        } = _ref4;
+        let {
+          validationResult,
+          field
+        } = action.payload;
+
+        if (!validationResult.isValid) {
+          dispatch({
+            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+            payload: {
+              fieldApiName: field.apiName,
+              errorMessage: validationResult.message
+            }
+          });
+        } else {
+          dispatch({
+            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+            payload: {
+              fieldApiName: field.apiName,
+              errorMessage: ""
+            }
+          });
+        }
+      },
+      [VALIDATE_FIELDS_RESULT]: _ref5 => {
+        let {
+          action,
+          state,
+          updateState,
+          dispatch
+        } = _ref5;
+        let {
+          validationResults,
+          fields
+        } = action.payload;
+        let formData = { ...state.behaviours.zform.formData
+        };
+        validationResults.forEach((validationResult, index) => {
+          let field = fields[index];
+
+          if (!validationResult.isValid) {
+            dispatch({
+              type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+              payload: {
+                fieldApiName: field.apiName,
+                errorMessage: validationResult.message
+              }
+            });
+          } else {
+            dispatch({
+              type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+              payload: {
+                fieldApiName: field.apiName,
+                errorMessage: ""
+              }
+            });
+          }
+        });
+      },
+      [FormConstants.FORM_SUBMIT]: _ref6 => {
+        let {
+          action,
+          dispatch
+        } = _ref6;
+        dispatch({
+          type: ZFORM_SUBMIT
+        });
+      },
+      [FormConstants.FORM_FIELD_BLURRED]: _ref7 => {
+        let {
+          action,
+          dispatch
+        } = _ref7;
+        dispatch({
+          type: ZFORM_VALIDATE_FIELD_REQUEST,
+          payload: {
+            fieldName: action.payload.fieldName
+          }
+        });
+      },
+      [FormConstants.FORM_FIELD_VALUE_CHANGE_REQUEST]: _ref8 => {
+        let {
+          action,
+          dispatch
+        } = _ref8;
+        dispatch({
+          type: ZFORM_FIELD_VALUE_CHANGE_REQUEST,
+          payload: {
+            fieldName: action.payload.fieldName,
+            newValue: action.payload.value
+          },
+          metaData: {}
+        });
+      }
+    };
+  }
+
+}
+
+export default EventHandlersFactory;