@ukhomeoffice/cop-react-form-renderer 6.15.4-alpha → 6.15.4

package/dist/components/FormRenderer/helpers/clearOutUncompletedRoutes.js

@@ -0,0 +1,323 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _mergeCollectionPages = _interopRequireDefault(require("../../../utils/CollectionPage/mergeCollectionPages"));
+var Utils = _interopRequireWildcard(require("./clearOutUncompletedRoutesUtils"));
+var _optionIsSelected = _interopRequireDefault(require("../../../utils/Component/optionIsSelected"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable no-param-reassign */
+/**
+ *  
+ * This function recursively reads in the non-collection pages and components and builds lists from it:
+ * 
+ * 1: allComponents. This is a map of all components in the form, keyed by the fully qualified component path.
+ *      If the component belongs to a page (or other parent entity) that has its own show_when rule, then this rule
+ *      is combined with the show_when rule of the component, so the decision as to whether the component's data should
+ *      exist can be made just by processing the component.
+ *      The main purpose of this map is to allow us to build a dependency graph in the function createComponentDependenciesGraph
+ * 
+ * 2: componentsToKeep: This is an object containing a count of how many times each component is defined. This is to support the
+ *      fact that a component can be used more than once in a form (but with mutually exclusive show_when rules so only used 
+ *      once with the same path). 
+ * 
+ * @param {Array} condensedPages All pages in the form, with the collection pages collated into a single object per collection
+ * @param {Object} formData The form payload
+ * @param {Map} componentByIdMap Map of all components, to enable performant lookup by id
+ * @param {Map} componentByFieldIdMap Map of all components, to enable performant lookup by fieldId
+ * @param {Object} 
+ * @return {Map, Object, Map} allComponents All components in form (including nested), keyed by path: 
+ *                              componentsToKeep A count of how many times each component is used, to prevent us deleting components defined > 1 times
+ *                              allCollections A map of collection objects, which are a grouping of the pages that make up a single collection 
+ */
+const createComponentMapsFromForm = (condensedPages, componentByIdMap, componentByFieldIdMap, formData) => {
+  const allComponents = new Map();
+  const componentsToKeep = {};
+  const allCollections = new Map();
+
+  /*
+   * Inner function to support the recursion required to traverse through the nested structures of the form
+   */
+  const recursivelyMapFieldsAndDeleteHiddenNested = (page, component, path) => {
+    var _component$data;
+    if (!component.fieldId) return; // Many component, such as warnings, html and details do not have data so we can ignore them        
+    path = path ? "".concat(path, ".").concat(component.fieldId) : component.fieldId; // Build up the path to reflect nested components
+    componentsToKeep[path] = (componentsToKeep[path] || 0) + 1; // We need to keep track of the count of each component path, to avoid pruning paths that exist elsewhere        
+    component.path = path; // Add the fully qualified path to the component, which will be required when resolving the dependencies later
+
+    // If the parent page has a rule, combine it with any component rule as we will be resolving dependencies for components only
+    if (page.show_when) {
+      component.show_when = component.show_when ? [].concat(Utils.toArray(page.show_when), Utils.toArray(component.show_when)) : page.show_when;
+    }
+    Utils.addValue(path, component, allComponents); // There can be more than one component per path, so keep a map of <path, array>
+    // recurse if there is nesting
+    if (component.components) {
+      component.components.forEach(c => {
+        recursivelyMapFieldsAndDeleteHiddenNested(page, c, path, allComponents, componentsToKeep, formData);
+      });
+    } else if (component !== null && component !== void 0 && (_component$data = component.data) !== null && _component$data !== void 0 && _component$data.options) {
+      var _component$data2;
+      component === null || component === void 0 || (_component$data2 = component.data) === null || _component$data2 === void 0 || (_component$data2 = _component$data2.options) === null || _component$data2 === void 0 || _component$data2.forEach(option => {
+        if (option.nested) {
+          if (!(0, _optionIsSelected.default)(formData[component.id], option)) {
+            option.nested.forEach(nestedComponent => {
+              // delete hidden nested question payload items when the parent option is not selected
+              Utils.deleteNodeByPath(formData, Utils.getNestedQuestionPath(path, nestedComponent.fieldId));
+            });
+          } else {
+            // If the option is selected, then add any nested components to the allComponents list. If the nested block has a show_when, pass it down to the child questions                        
+            const blockShowWhen = option.show_when;
+            option.nested.forEach(nestedComponent => {
+              if (blockShowWhen) nestedComponent.show_when = blockShowWhen;
+              recursivelyMapFieldsAndDeleteHiddenNested(page, nestedComponent, Utils.getImmediateParent(path), allComponents, componentsToKeep, formData);
+            });
+          }
+        }
+      });
+    }
+  };
+
+  // Entry point for the recursive traverse of the form specification. 
+  condensedPages === null || condensedPages === void 0 || condensedPages.forEach(page => {
+    // Make the distinction between collections (which will be processed separately) and non-collections, which will be processed here.
+    if (page.childPages) {
+      allCollections.set(page.collection.name, page);
+    } else {
+      var _page$components;
+      (_page$components = page.components) === null || _page$components === void 0 || _page$components.forEach(useComponentInPage => {
+        const componentObj = Utils.findComponentDefinitionInForm(useComponentInPage, componentByIdMap, componentByFieldIdMap);
+        recursivelyMapFieldsAndDeleteHiddenNested(page, componentObj, null, allComponents, componentsToKeep, formData);
+      });
+    }
+  });
+  return {
+    allComponents,
+    componentsToKeep,
+    allCollections
+  };
+};
+/**
+ *  
+ * This function iterates through the allComponents list. For each component, it will derive all payload paths 
+ * that this component is dependent on. The same component might be defined more than once in the form, so add the dependencies
+ * for all the component definitions.
+ * 
+ * @param {Map} allDependencyRelationships A map of each component with dependencies. The key is the fully qualified path and the value is a Set of all the paths that this component is dependent on.   
+ * @param {Map} allComponents All components in form (including nested), keyed by path. Used to build the allDependencyRelationships
+ * @return {Map }allDependencyRelationships graph of the relationships between all entities
+ */
+const createComponentDependenciesGraph = allComponents => {
+  const allDependencyRelationships = new Map();
+  allComponents === null || allComponents === void 0 || allComponents.forEach(componentArray => {
+    componentArray === null || componentArray === void 0 || componentArray.forEach(component => {
+      if (!component.fieldId) return;
+      const componentDependencies = Utils.getDependencies(component);
+      if (componentDependencies) {
+        if (allDependencyRelationships.has(component.path)) {
+          const existingSet = allDependencyRelationships.get(component.path);
+          componentDependencies.forEach(dep => existingSet.add(dep));
+        } else {
+          allDependencyRelationships.set(component.path, new Set(componentDependencies));
+        }
+      }
+    });
+  });
+  return allDependencyRelationships;
+};
+
+/**
+ * 
+ * This function loops through each entry in the allDependencyRelationships map. Each entry will contain a Set of all
+ * paths that the key path is dependent on. Recursively delve into each dependency path and repeat the process until we
+ * have reached an entry that has no dependencies. At this point we can safely resolve the dependency using its show_when rule, 
+ * and unwind the recursion. 
+ * 
+ * Because all the components are inter-connected, this could result in resolving the same entry repeatedly, so keep a 'visited' 
+ * array to prevent this.
+ *   
+ * @param {Object} formData The form payload
+ * @param {Map} allComponents All components in form (including nested), keyed by path
+ * @param {Object} componentsToKeep A count of how many times each component is used, to prevent us deleting components defined > 1 times
+ * @param {Map} allDependencyRelationships A map of each component with dependencies. The key is the fully qualified path and the value is a Set of all the paths that this component is dependent on.   
+ * @param {Map} allCollections A map of collection objects, which are a grouping of the pages that make up a single collection  
+ * @param {Object} form The form specification
+ */
+const resolveComponentDependenciesGraph = (allDependencyRelationships, allComponents, componentsToKeep, allCollections, form, formData) => {
+  /*
+   * Inner function to support the recursion required to traverse through the nested nature of the allDependencyRelationships
+   */
+  const recursivelyResolveDependencies = (visited, dependentComponent, dependencyRelationships) => {
+    if (visited.has(dependentComponent)) return;
+    visited.add(dependentComponent);
+    const dependencies = dependencyRelationships.get(dependentComponent.path);
+    dependencies === null || dependencies === void 0 || dependencies.forEach(dependencyPath => {
+      const dependencyComponents = Utils.getDependencyObjectFromPath(dependencyPath, allComponents);
+      if (dependencyComponents) {
+        dependencyComponents.forEach(dependency => {
+          if (!visited.has(dependency)) {
+            recursivelyResolveDependencies(visited, dependency, dependencyRelationships);
+          }
+        });
+      } else {
+        // We are here if the dependency path was not found in the list of allComponents. This is valid and can happen when 
+        // a component is dependent on a field that was generated by cop-ui, e.g. jobHolderStaffDetails.linemanagerEmail.
+        // However, there is an edge case (described in the message below) that we need to validate for.  
+        const arrayNamePattern = /([a-zA-Z_$][\w$]*)\[\d+\]/;
+        const match = dependencyPath.match(arrayNamePattern);
+        if (match) {
+          const collectionName = match[1];
+          const collection = allCollections.get(collectionName);
+          if (collection) {
+            var _collection$childPage;
+            (_collection$childPage = collection.childPages) === null || _collection$childPage === void 0 || _collection$childPage.forEach(childPage => {
+              if (childPage.show_when) {
+                const message = "It is not possible to reliably clean hidden data when a component is dependent on a \n                                collection's data, and that collection is itself dependent on data elsewhere in the form.\n                                The dependency path is ".concat(dependencyPath, ", and the chained show_when is ").concat(JSON.stringify(childPage.show_when), ".\n                                The form will need to be changed to break this chained dependency");
+                throw new Error(message);
+              }
+              ;
+            });
+          }
+        }
+      }
+    });
+    // Whilst unravelling the recursion, we can start deleting from the leaf upwards
+    if (!Utils.isShowEntity(dependentComponent, formData)) {
+      Utils.deleteComponentData(formData, dependentComponent.path, dependentComponent, componentsToKeep);
+    }
+  };
+  const visited = new Set();
+  allDependencyRelationships === null || allDependencyRelationships === void 0 || allDependencyRelationships.forEach((dependencies, dependentComponentPath) => {
+    // Each path that a component is dependent on may have > 1 possible dependent components, if a field is used twice
+    const dependentComponents = allComponents.get(dependentComponentPath);
+    dependentComponents === null || dependentComponents === void 0 || dependentComponents.forEach(dependentComponent => {
+      if (!visited.has(dependentComponent)) {
+        recursivelyResolveDependencies(visited, dependentComponent, allDependencyRelationships, form, formData, allComponents, componentsToKeep, allCollections);
+      }
+    });
+  });
+};
+
+/**
+ * For each collection, iterate through the payload array's objects, and apply the collections show_when
+ * rules for each payload object.
+ * 
+ * Some of the rules may be dependent on payload items outside the collection. These will already have been cleansed
+ * so will be in a reliable state.   
+ * 
+ * @param {Map} allCollections A map of collection objects, which are a grouping of the pages that make up a single collection  
+ * @param {Object} formData The form payload
+ * @param {Map} componentByIdMap Map of all components, to enable performant lookup by id
+ * @param {Map} componentByFieldIdMap Map of all components, to enable performant lookup by fieldId
+ */
+const cleanseCollectionData = (allCollections, formData, componentByIdMap, componentByFieldIdMap) => {
+  allCollections === null || allCollections === void 0 || allCollections.forEach((collection, collectionName) => {
+    const collectionDataArray = formData[collectionName];
+    collectionDataArray === null || collectionDataArray === void 0 || collectionDataArray.forEach(collectionDataEntry => {
+      var _collection$childPage2;
+      // The forms are written such that a show_when in a collection array object can be evaluated against the data relative to that data object
+      // OR against the data relative to the root of the form. To achieve that, we'll copy the collection object to the root of the form before evaluating
+      const dataForEvaluation = _objectSpread(_objectSpread({}, formData), collectionDataEntry);
+      const pathsToKeep = new Set();
+      const componentsToPrune = new Map();
+      (_collection$childPage2 = collection.childPages) === null || _collection$childPage2 === void 0 || _collection$childPage2.forEach(childPage => {
+        var _childPage$components;
+        const showPage = Utils.isShowEntity(childPage, dataForEvaluation);
+        (_childPage$components = childPage.components) === null || _childPage$components === void 0 || _childPage$components.forEach(useComponentInPage => {
+          const componentObj = Utils.findComponentDefinitionInForm(useComponentInPage, componentByIdMap, componentByFieldIdMap);
+          // Non-data components can be ignored (eg html)
+          if (!componentObj.fieldId) return;
+          const showComponentOnPage = Utils.isShowEntity(useComponentInPage, dataForEvaluation);
+          if (showPage && showComponentOnPage && Utils.isShowEntity(componentObj, dataForEvaluation)) {
+            // There may be >1 components with the same path (eg quantity in EAB2), so don't delete hidden components if they are required elsewhere
+            pathsToKeep.add(componentObj.fieldId);
+          } else {
+            componentsToPrune.set(componentObj.id, componentObj);
+          }
+        });
+      });
+      Utils.pruneCollectionEntry(pathsToKeep, componentsToPrune, collectionDataEntry, formData);
+    });
+    // 
+    if (collectionDataArray) Utils.removeObjectWithOnlySingleIdField(collectionDataArray);
+  });
+};
+
+/**
+ * 
+ * The purpose of this function is to apply the show_when rules defined in the form specification to the 
+ * form payload (formData), and remove any data that should not be shown according to those rules.
+ * (the reason this data exists in the payload is that users can answer a question in such a way that 
+ * other questions are 'shown' to them, which are then complete. The user can then go back and change the original
+ * question to then 'hide' those questions, but the answers they gave persist in the payload. The must be cleansed
+ * before being submitted.
+ * 
+ * There are 2 types of payload data that have to be treated differently by this function for it to work.
+ * 
+ * 1. Data from non-repeating pages, containing components.
+ * 
+ * Each data item captured will be written to the payload as a field with the name of the fieldId of the payload.
+ * In the case of components that are nested within 'container' components, the payload will reflect the nesting.
+ * There is no limit to the level of nesting in a form.
+ * 
+ * To cleanse the payload for this type of data, we do the following (high level description, see method comments for detail):
+ * 
+ * - build a map of all components, keyed by their payload path (required for the next step)
+ * - for all of these components that have dependencies (show_when rules), create a graph datastructure to show all components
+ *   on which a component is dependent, and then all components that those components may be dependent on. There is no limit to 
+ *   the depth of these chained dependencies.
+ * - the reason for building a graph of these dependency chains is so we know the sequence in which we must resolve the dependencies. 
+ *   For any given chain of dependencies it is essential that we resolve the dependencies starting at the end of the chains, and work our way
+ *   back up the chain. If not, we could be resolving a dependency based on a payload item that itself will later be deleted.
+ *   Therefore, the final step is to recursively traverse the dependency graph, resolving the dependency rule for the components in 
+ *   the chain from the leaf back up to the parent node. 
+ * 
+ * 2. Page collection data
+ * 
+ * A page collection is a set of one or more pages which (as a group) can be filled in as many times is required
+ * by the user. For example, in EAB, you can add as many item-seal-details to an EAB form as are required. An item-seal-detail
+ * is made up of several different pages, all grouped. The data saved will be an array representing the whole collection, with
+ * each object in the array representing a single collection entry (a single item-seal-detail in this example).
+ * 
+ * Cleanse collection data has to be driven from the payload rather than the form, as there are repeated objects in an array
+ * representing the data. Each one has to be treated independently as the data to be cleansed can be different in each one.
+ *  
+ * - For each collection type, iterate through each payload object and treat it like an independent payload..
+ * - For each collection payload object, iterate through the collection's pages and components, and apply all the show_when rules
+ *   found at both page and component level to the payload. 
+ * - Repeat for each payload object
+ * - Repeat for all collections
+ * 
+ * @param {*} form 
+ * @param {*} formData 
+ * @returns {*} cleansed form data 
+ */
+const clearOutUncompletedRoutes = (form, formData) => {
+  // Load components into maps keyed on id and field for subsequent performant access
+  const componentByIdMap = new Map(form.components.map(c => [c.id, c]));
+  const componentByFieldIdMap = new Map(form.components.map(c => [c.fieldId, c]));
+
+  // Group all pages relating to a page-collection into a single object to aid collection 
+  // processing, and to allow us to differentiate between a collection and non-collection page.
+  const condensedPages = (0, _mergeCollectionPages.default)(form.pages);
+  const {
+    allComponents,
+    componentsToKeep,
+    allCollections
+  } = createComponentMapsFromForm(condensedPages, componentByIdMap, componentByFieldIdMap, formData);
+  const allDependencyRelationships = createComponentDependenciesGraph(allComponents);
+  resolveComponentDependenciesGraph(allDependencyRelationships, allComponents, componentsToKeep, allCollections, form, formData);
+  cleanseCollectionData(allCollections, formData, componentByIdMap, componentByFieldIdMap);
+
+  // The cleansing above may have left empty arrays and collection IDs. Tidy these up.
+  Utils.removeEmptyArraysAndUnusedCollectionIDs(formData);
+  return formData;
+};
+var _default = exports.default = clearOutUncompletedRoutes;