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

package/es/platform/zform/domain/ZValidationRule.js

@@ -0,0 +1,79 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+export default class ZValidationRule {
+  constructor(validationRuleData) {
+    _defineProperty(this, "displayLabel", void 0);
+
+    _defineProperty(this, "fieldConditions", void 0);
+
+    _defineProperty(this, "modifiedTime", void 0);
+
+    _defineProperty(this, "fieldName", void 0);
+
+    _defineProperty(this, "executeInHelpCentre", void 0);
+
+    _defineProperty(this, "createdBy", void 0);
+
+    _defineProperty(this, "createdTime", void 0);
+
+    _defineProperty(this, "modifiedBy", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "systemGenerated", void 0);
+
+    _defineProperty(this, "layoutId", void 0);
+
+    _defineProperty(this, "status", void 0);
+
+    _defineProperty(this, "isActive", void 0);
+
+    this.displayLabel = validationRuleData.displayLabel;
+    this.fieldConditions = validationRuleData.fieldConditions;
+    this.modifiedTime = validationRuleData.modifiedTime;
+    this.fieldName = validationRuleData.fieldName;
+    this.executeInHelpCentre = validationRuleData.executeInHelpCentre;
+    this.createdBy = validationRuleData.createdBy;
+    this.createdTime = validationRuleData.createdTime;
+    this.modifiedBy = validationRuleData.modifiedBy;
+    this.id = validationRuleData.id;
+    this.systemGenerated = validationRuleData.systemGenerated;
+    this.layoutId = validationRuleData.layoutId;
+    this.status = validationRuleData.status;
+  }
+
+  getId() {
+    return this.id;
+  }
+
+  getFieldApiName() {
+    return this.fieldName;
+  }
+
+  activate() {
+    this.isActive = true;
+  }
+
+  deActivate() {
+    this.isActive = false;
+  }
+
+  toObject() {
+    return {
+      displayLabel: this.displayLabel,
+      fieldConditions: this.fieldConditions,
+      modifiedTime: this.modifiedTime,
+      fieldName: this.fieldName,
+      executeInHelpCentre: this.executeInHelpCentre,
+      createdBy: this.createdBy,
+      createdTime: this.createdTime,
+      modifiedBy: this.modifiedBy,
+      id: this.id,
+      systemGenerated: this.systemGenerated,
+      layoutId: this.layoutId,
+      status: this.status,
+      isActive: this.isActive
+    };
+  }
+
+}

package/es/platform/zform/domain/interfaces/FieldCondition.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zform/domain/interfaces/ILayoutRuleHelper.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zform/domain/interfaces/IValidationRuleHelper.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zform/domain/interfaces/IZForm.js

@@ -0,0 +1 @@
+;

package/es/platform/zform/domain/interfaces/ZLayoutRuleData.js

@@ -0,0 +1 @@
+export {};

package/es/platform/zform/domain/interfaces/ZValidationRuleData.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,64 @@
+import { calculateLayoutRulesResult } from "./calculateLayoutRulesResult";
+import applySectionLayoutRules from "./applySectionLayoutRules";
+import applyFieldLayoutRules from "./applyFieldLayoutRules";
+export default class LayoutRuleApplier {
+  applyRules(_ref) {
+    let {
+      layoutRules,
+      formData,
+      myForm
+    } = _ref;
+    let data = {};
+    Object.keys(formData).forEach(key => {
+      data[key] = formData[key].value;
+    }); //let state=fields, sections, sectionsOrder 
+
+    let sections = {};
+    myForm.sections.forEach(section => {
+      let fieldsApiName = section.fields.map(field => field.apiName);
+      sections[section.name] = { ...section,
+        fields: fieldsApiName
+      };
+    });
+    let fields = myForm.sections.flatMap(section => section.fields).reduce((acc, field) => {
+      acc[field.apiName] = field;
+      return acc;
+    }, {});
+    let sectionsOrder = myForm.sections.map(section => section.name);
+    let state = {
+      sections,
+      fields,
+      sectionsOrder,
+      layoutRules: {
+        rules: layoutRules
+      }
+    };
+    let layoutRulesResult = calculateLayoutRulesResult(state, data);
+    let sectionAppliedLayoutRule = applySectionLayoutRules(layoutRulesResult, sections);
+    let fieldAppliedLayoutRule = applyFieldLayoutRules(layoutRulesResult, fields);
+    let sectionResult = Object.keys(sectionAppliedLayoutRule).reduce((acc, key) => {
+      if (sectionAppliedLayoutRule[key].visibility != undefined) {
+        acc[key] = {
+          visibility: sectionAppliedLayoutRule[key].visibility
+        };
+      }
+
+      return acc;
+    }, {});
+    let fieldResult = Object.keys(fieldAppliedLayoutRule).reduce((acc, key) => {
+      if (fieldAppliedLayoutRule[key].visibility != undefined) {
+        acc[key] = {
+          visibility: fieldAppliedLayoutRule[key].visibility,
+          isMandatory: fieldAppliedLayoutRule[key].isMandatory
+        };
+      }
+
+      return acc;
+    }, {});
+    return {
+      sectionResult,
+      fieldResult
+    };
+  }
+
+}

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

@@ -0,0 +1,29 @@
+import { getLayoutRuleAppliedFieldProperties } from "./getLayoutRuleAppliedFieldProperties";
+export default function applyFieldLayoutRules(layoutRulesResult, fields) {
+  const {
+    hideFieldIds,
+    showFieldIds,
+    setMandatoryFieldIds,
+    removeMandatoryFieldIds
+  } = layoutRulesResult;
+  const allRuleAppliedFieldsIds = [...hideFieldIds, ...showFieldIds, ...setMandatoryFieldIds, ...removeMandatoryFieldIds];
+  const allRuleAppliedFields = {}; // let hasChange = false
+
+  allRuleAppliedFieldsIds.forEach(fieldId => {
+    const fieldMeta = fields[fieldId];
+
+    if (fieldMeta) {
+      const extraProperties = getLayoutRuleAppliedFieldProperties({
+        fieldId,
+        layoutRulesResult,
+        fieldMeta
+      });
+      allRuleAppliedFields[fieldId] = { ...fieldMeta,
+        ...extraProperties
+      };
+    }
+  });
+  return { ...fields,
+    ...allRuleAppliedFields
+  };
+}

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

@@ -0,0 +1,28 @@
+import { getLayoutRuleAppliedSectionProperties } from "./getLayoutRuleAppliedSectionProperties";
+export default function applySectionLayoutRules(layoutRulesResult, sections) {
+  // const layoutRulesResult = calculateLayoutRulesResult(state);
+  const {
+    hideSectionIds,
+    showSectionIds
+  } = layoutRulesResult;
+  const allRuleAppliedSectionsIds = [...hideSectionIds, ...showSectionIds];
+  const allRuleAppliedSections = {}; // let hasChange = false
+
+  allRuleAppliedSectionsIds.forEach(sectionId => {
+    const sectionMeta = sections[sectionId];
+
+    if (sectionMeta) {
+      const extraProperties = getLayoutRuleAppliedSectionProperties({
+        sectionId,
+        sectionMeta,
+        layoutRulesResult
+      });
+      allRuleAppliedSections[sectionId] = { ...sectionMeta,
+        ...extraProperties
+      };
+    }
+  });
+  return { ...sections,
+    ...allRuleAppliedSections
+  };
+}

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

@@ -0,0 +1,228 @@
+import { runSingleFieldCondition } from "./runSingleFieldCondition";
+import { constructFieldIdAndSectionIdMap } from "./constructFieldIdAndSectionIdMap";
+import { getLayoutRules } from "./selectors";
+/* eslint-disable import/prefer-default-export */
+
+function getPassedFormRules(_ref) {
+  let {
+    fields,
+    formValues,
+    rules = [],
+    isFieldExists
+  } = _ref;
+  let passedRules = [];
+  rules.filter(rule => isFieldExists(rule.fieldName)).forEach(rule => {
+    const {
+      fieldName,
+      fieldConditions
+    } = rule;
+    const results = fieldConditions.map(fieldCondition => {
+      const result = runSingleFieldCondition({
+        fieldCondition,
+        fields,
+        formValues
+      }); // return result;
+
+      if (result !== null) {
+        const {
+          actions
+        } = fieldCondition;
+        return {
+          fieldName,
+          actions
+        };
+      }
+
+      return null;
+    });
+    passedRules = passedRules.concat(results.filter(o => o !== null));
+  });
+  return passedRules;
+}
+
+const includes = (arr, data) => arr.indexOf(data) !== -1;
+
+const notInclude = (arr, data) => arr.indexOf(data) === -1;
+
+function combineArrayWithoutDuplicate(mainArray, subArray) {
+  subArray.forEach(data => {
+    if (notInclude(mainArray, data)) {
+      mainArray.push(data);
+    }
+  });
+  return mainArray;
+}
+
+function removeArrayElementFromOtherArray(array1, array2) {
+  array2.forEach(ele => {
+    const index = array1.indexOf(ele);
+
+    if (index !== -1) {
+      array1.splice(index, 1);
+    }
+  });
+  return array1;
+}
+
+function fieldNameMapper(data) {
+  return data.fieldName;
+}
+
+function getInvolvedFieldsAndSections(layoutRules) {
+  const allActions = [];
+  layoutRules.forEach(rule => {
+    const {
+      fieldConditions
+    } = rule;
+    fieldConditions.forEach(condition => {
+      condition.actions && allActions.push(condition.actions);
+    });
+  });
+  return getInvolvedFieldsAndSectionsFromActionsArray(allActions);
+}
+
+function getInvolvedFieldsAndSectionsFromActionsArray(actionsArray) {
+  const involvedSectionIds = [];
+  const involvedFieldIds = [];
+  const involvedMandatoryFieldIds = [];
+  actionsArray.forEach(actions => {
+    const {
+      showFields = [],
+      showSections = [],
+      setMandatoryFields = []
+    } = actions;
+    combineArrayWithoutDuplicate(involvedSectionIds, showSections.filter(sectionName => !!sectionName));
+    combineArrayWithoutDuplicate(involvedFieldIds, showFields.map(fieldNameMapper).filter(fieldName => !!fieldName));
+    combineArrayWithoutDuplicate(involvedMandatoryFieldIds, setMandatoryFields.map(fieldNameMapper).filter(fieldName => !!fieldName)); // arrayWithoutDuplicateOrderIntact([...involvedSectionIds, ...showSections]);
+  });
+  return {
+    involvedSectionIds,
+    involvedFieldIds,
+    involvedMandatoryFieldIds
+  };
+}
+
+function createMapForShowHide(hideIds, showIds) {
+  const mapper = {};
+  showIds.forEach(id => {
+    mapper[id] = true;
+  });
+  hideIds.forEach(id => {
+    mapper[id] = false;
+  });
+  return mapper;
+}
+
+export function calculateLayoutRulesResult(state, formValues) {
+  const {
+    fields,
+    sections,
+    sectionsOrder
+  } = state;
+
+  const isFieldExists = id => !!fields[id];
+
+  const isSectionExists = id => !!sections[id];
+
+  const layoutRules = getLayoutRules(state);
+  const fieldIdAndSectionIdMap = constructFieldIdAndSectionIdMap(sections, sectionsOrder);
+
+  function getSectionIdByFieldId(fieldId) {
+    const sectionId = fieldIdAndSectionIdMap[fieldId];
+    return sectionId;
+  }
+
+  const passedRules = getPassedFormRules({
+    fields: state.fields,
+    formValues,
+    rules: layoutRules,
+    isFieldExists
+  });
+  const {
+    involvedSectionIds: hideSectionIds,
+    involvedFieldIds: hideFieldIds,
+    involvedMandatoryFieldIds: removeMandatoryFieldIds
+  } = getInvolvedFieldsAndSections(layoutRules);
+  const {
+    involvedSectionIds: showSectionIds,
+    involvedFieldIds: showFieldIds,
+    involvedMandatoryFieldIds: setMandatoryFieldIds
+  } = getInvolvedFieldsAndSectionsFromActionsArray(passedRules.map(r => r.actions));
+  removeArrayElementFromOtherArray(hideFieldIds, showFieldIds);
+  removeArrayElementFromOtherArray(hideSectionIds, showSectionIds);
+  removeArrayElementFromOtherArray(removeMandatoryFieldIds, setMandatoryFieldIds); // TODO
+  // AdditionalCheck: primary field is not showing in form, disable the actions, even if rule passed
+  // NOTE: below logic only work based on
+  // 1.  One Field never have two parent
+  // 2.  One Parent Field never have become child for other Filed
+  // 3.  One Child Field can have other Filed as child (which  is not parent of other filed)
+  // DANGER:
+  // 1.  when first Layout Rules Primary field was able hide by other rules this code will not work perfectly
+  // const tempShowFieldIdsMap = createMapForShowHide(hideFieldIds, showFieldIds);
+  // const tempShowSectionIdsMap = createMapForShowHide(
+  //   hideSectionIds,
+  //   showSectionIds
+  // );
+
+  passedRules.forEach(rule => {
+    const {
+      fieldName,
+      actions
+    } = rule;
+    const primaryFieldId = fieldName;
+    const primaryFieldSection = getSectionIdByFieldId(primaryFieldId);
+
+    if (includes(hideFieldIds, primaryFieldId) || includes(hideSectionIds, primaryFieldSection)) {
+      const {
+        showFields = [],
+        showSections = [],
+        setMandatoryFields = []
+      } = actions;
+      moveIdsFormShowIdsToHideIds(showSections, showSectionIds, hideSectionIds);
+      moveIdsFormShowIdsToHideIds(showFields.map(f => f.fieldName), showFieldIds, hideFieldIds);
+      moveIdsFormShowIdsToHideIds(setMandatoryFields.map(f => f.fieldName), setMandatoryFieldIds, removeMandatoryFieldIds);
+    }
+  });
+  /** NOTE:
+   *  if section hide, that section fields set as hide in state
+   *  But don't update it in state (store)
+   */
+
+  clearNotExistingData(hideFieldIds, isFieldExists);
+  clearNotExistingData(showFieldIds, isFieldExists);
+  clearNotExistingData(hideSectionIds, isSectionExists);
+  clearNotExistingData(hideSectionIds, isSectionExists);
+  clearNotExistingData(removeMandatoryFieldIds, isFieldExists);
+  clearNotExistingData(setMandatoryFieldIds, isFieldExists);
+  return {
+    showFieldIdsMap: createMapForShowHide(hideFieldIds, showFieldIds),
+    showSectionIdsMap: createMapForShowHide(hideSectionIds, showSectionIds),
+    setMandatoryFieldIdsMap: createMapForShowHide(removeMandatoryFieldIds, setMandatoryFieldIds),
+    fieldIdAndSectionIdMap,
+    showSectionIds,
+    setMandatoryFieldIds,
+    showFieldIds,
+    hideSectionIds,
+    removeMandatoryFieldIds,
+    hideFieldIds
+  };
+}
+
+function clearNotExistingData(array, isExists) {
+  for (let index = array.length - 1; index >= 0; index--) {
+    if (isExists(array[index]) === false) {
+      array.splice(index, 1);
+    }
+  }
+}
+
+function moveIdsFormShowIdsToHideIds(ids, showIds, hideIds) {
+  ids.forEach(id => {
+    const index = showIds.indexOf(id);
+
+    if (index !== -1 && id && notInclude(hideIds, id)) {
+      showIds.splice(index, 1);
+      hideIds.push(id);
+    }
+  });
+}

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

@@ -0,0 +1,10 @@
+export function constructFieldIdAndSectionIdMap(sections, sectionsOrder) {
+  const mapper = {};
+  sectionsOrder.forEach(sectionId => {
+    const section = sections[sectionId];
+    section.fields.forEach(fieldId => {
+      mapper[fieldId] = section.id;
+    });
+  });
+  return mapper;
+}

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

@@ -0,0 +1,130 @@
+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 function validatePattern(pattern, matchedResult) {
+  const jsPattern = pattern.replace(/and/g, '&&').replace(/or/g, '||');
+  const ast = jsep(jsPattern);
+  const isValid = evaluate(ast, matchedResult);
+  return isValid;
+}

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

@@ -0,0 +1,60 @@
+export function getLayoutRuleAppliedFieldProperties(_ref) {
+  let {
+    fieldId,
+    fieldMeta,
+    layoutRulesResult
+  } = _ref;
+  const visibility = getFieldVisibility({
+    layoutRulesResult,
+    fieldId,
+    defaultValue: fieldMeta.visibility
+  });
+  const isMandatory = getFieldMandatory({
+    layoutRulesResult,
+    fieldId,
+    defaultValue: fieldMeta.isMandatory
+  });
+  const field = {
+    visibility,
+    isMandatory
+  };
+  return field;
+}
+
+function getFieldMandatory(_ref2) {
+  let {
+    layoutRulesResult,
+    fieldId,
+    defaultValue
+  } = _ref2;
+
+  if (!layoutRulesResult || !layoutRulesResult.setMandatoryFieldIdsMap) {
+    return defaultValue;
+  }
+
+  const isFieldMandatoryByLayoutRule = layoutRulesResult.setMandatoryFieldIdsMap[fieldId];
+  const isMandatory = isFieldMandatoryByLayoutRule === true ? true : isFieldMandatoryByLayoutRule === false ? false : defaultValue;
+  return isMandatory;
+}
+
+function getFieldVisibility(_ref3) {
+  let {
+    layoutRulesResult,
+    fieldId,
+    defaultValue
+  } = _ref3;
+
+  if (!layoutRulesResult || !layoutRulesResult.showFieldIdsMap) {
+    return defaultValue;
+  }
+
+  const {
+    showFieldIdsMap,
+    showSectionIdsMap,
+    fieldIdAndSectionIdMap
+  } = layoutRulesResult;
+  const isFieldShowByLayoutRule = showFieldIdsMap[fieldId];
+  const isSectionShowByLayoutRule = showSectionIdsMap[fieldIdAndSectionIdMap[fieldId]];
+  const visibility = isSectionShowByLayoutRule === false ? false : isFieldShowByLayoutRule === true ? true : isFieldShowByLayoutRule === false ? false : defaultValue;
+  return visibility;
+}